x/ranger-tempest-plugin
Code Issues Proposed changes

Modifications to function with 3.6 Ranger Build

Browse Source 
Several tests because non-functional after git removal
and python 3.6 code update. This patchset will ensure
that these tests function with current ranger codebase.
Also removes erroneous use of rand_region functionality
when testing flavors, flavor testing should always use
real ranger regions, otherwise database will require
manual purging of flavor after it goes into error status.

Change-Id: I941b45b62ae1288e5594942d4567dc90fc968842
This commit is contained in:
jh629g 2020-01-16 10:06:32 -06:00
parent acd7c258a9
commit 57323cb05d
15 changed files with 315 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
Dockerfile
View File

@ -5,8 +5,8 @@ ENV container docker
ENV LC_ALL C.UTF-8 ENV LC_ALL C.UTF-8
ENV LANG C.UTF-8 ENV LANG C.UTF-8
RUN apt update && \ RUN apt -qq update && \
apt -y install git \ apt -qq -y install git \
netcat \ netcat \
netbase \ netbase \
openssh-server \ openssh-server \
@ -45,7 +45,7 @@ WORKDIR /
COPY . ranger-tempest-plugin/ COPY . ranger-tempest-plugin/
WORKDIR /ranger-tempest-plugin/ WORKDIR /ranger-tempest-plugin/
RUN python setup.py develop RUN python3 setup.py develop
########################################################################## ##########################################################################
### END OF ranger-tempest-plugin setup ### END OF ranger-tempest-plugin setup
@ -58,25 +58,15 @@ RUN python setup.py develop
### reset workdir to root before executing tempest steps ### reset workdir to root before executing tempest steps
WORKDIR / WORKDIR /
### git clone tempest
RUN git clone https://git.openstack.org/openstack/tempest
### now run 'pip install -r requirements'
RUN pip3 install -r /tempest/requirements.txt && \
pip3 install -r /tempest/test-requirements.txt
### create required tempest directories - and remove .stestr folder ### create required tempest directories - and remove .stestr folder
RUN mkdir -p /tempest/logs \ RUN mkdir -p /tempest/logs \
&& mkdir -p /etc/tempest \
&& mkdir -p /tempest/tempest_lock \ && mkdir -p /tempest/tempest_lock \
&& mkdir -p /tempest/images \ && mkdir -p /tempest/images \
&& mkdir -p /var/log/tempest \ && mkdir -p /var/log/tempest
&& rm -rf /tempest/.stestr \
&& rm -rf /tempest/.stestr.conf
# copy tempest test setup files # copy tempest test setup files
COPY tempest_setup/create_tenant.sh /tempest/etc COPY tempest_setup/tempest.conf /etc/tempest
COPY tempest_setup/accounts.yaml /tempest/etc
COPY tempest_setup/tempest.conf /tempest/etc
########################################################################## ##########################################################################
### END OF openstack tempest setup steps ### END OF openstack tempest setup steps
@ -86,9 +76,8 @@ COPY tempest_setup/tempest.conf /tempest/etc
### RUN tempest tests on test_regions ### RUN tempest tests on test_regions
########################################################################## ##########################################################################
### create egg-info for tempest ### create egg-info for tempest
RUN cd /tempest && \
python setup.py develop
WORKDIR /ranger-tempest-plugin
#ENTRYPOINT stestr run ranger_tempest_plugin.tests.api.test_regions \ #ENTRYPOINT stestr run ranger_tempest_plugin.tests.api.test_regions \
# && /bin/bash # && /bin/bash
#ENTRYPOINT stestr run ranger_tempest_plugin.tests.api.test_flavors/ \ #ENTRYPOINT stestr run ranger_tempest_plugin.tests.api.test_flavors/ \

2
ranger_tempest_plugin/services/base_client.py
View File

@ -126,7 +126,7 @@ class RangerClientBase(rest_client.RestClient):
return resp.headers['x-subject-token'] return resp.headers['x-subject-token']
except Exception as ex: except Exception as ex:
raise ConnectionError(ex.message) raise ConnectionError(str(ex))
def get_headers(self, accept_type=None, send_type=None): def get_headers(self, accept_type=None, send_type=None):
if self.rbac: if self.rbac:

73
ranger_tempest_plugin/tests/api/base.py
View File

@ -26,7 +26,8 @@ class BaseOrmTest(test.BaseTestCase):
client_manager = clients.OrmClientManager client_manager = clients.OrmClientManager
credentials = ['admin', 'primary', 'alt'] credentials = ['admin', 'primary', 'alt']
identity_url = CONF.identity.uri_v3 or ""
identity_url = identity_url.strip('/v3')
build_timeout = 120 build_timeout = 120
build_interval = 10 build_interval = 10
@ -34,6 +35,74 @@ class BaseOrmTest(test.BaseTestCase):
def setup_clients(cls): def setup_clients(cls):
super(BaseOrmTest, cls).setup_clients() super(BaseOrmTest, cls).setup_clients()
cls.identity_client = cls.os_admin.projects_client cls.identity_client = cls.os_admin.projects_client
cls.region_client = cls.os_admin.rms_client
# Get regions in ranger deployment
_, regions_list = cls.region_client.list_regions()
region_names = [x['name'] for x in regions_list['regions']]
# Check if region and alt region exist. If not, create those regions.
if (CONF.identity.region not in region_names):
cls.region_client.create_region(
CONF.identity.region,
**{'id': CONF.identity.region,
'name': CONF.identity.region,
'description': 'region for testing',
'status': 'functional',
'rangerAgentVersion': '3.0',
'OSVersion': 'stein',
'CLLI': '123450',
'address': {'country': 'This', 'state': 'region',
'city': 'is for', 'street': 'test',
'zip': 'purposes'},
'metadata': {'meta1': ['region']},
'designType': 'large',
'endpoints': [{
'publicURL':
'https://dashboard-ranger.%s.cci.att.com'
% CONF.identity.region,
'type': 'dashboard'
}, {
'publicURL': cls.identity_url,
'type': 'identity'
}, {
'publicURL':
'https://ranger-agent-nc.%s.cci.att.com'
% CONF.identity.region,
'type': 'ord'
}]})
# TODO(jh629g): configuration of alternate region for testing
# this plugin needs to be refactored to ensure all region
# creation in this plugin exists in only one place.
if (CONF.ranger.alt_region not in region_names) and \
CONF.ranger.alt_region_available is True:
cls.region_client.create_region(
CONF.ranger.alt_region,
**{'status': 'functional',
'rangerAgentVersion': '3.0',
'OSVersion': 'stein',
'CLLI': '123450',
'address': {'country': 'This', 'state': 'region',
'city': 'is for', 'street': 'test',
'zip': 'purposes'},
'metadata': {'meta1': ['alt_region']},
'designType': 'large',
'endpoints': [{
'publicURL':
'https://dashboard-ranger.%s.cci.att.com'
% CONF.ranger.alt_region,
'type': 'dashboard'
}, {
'publicURL': 'https://identity-nc.%s.cci.att.com'
% CONF.ranger.alt_region,
'type': 'identity'
}, {
'publicURL':
'https://ranger-agent-nc.%s.cci.att.com'
% CONF.ranger.alt_region,
'type': 'ord'
}]})
@classmethod @classmethod
def skip_checks(cls): def skip_checks(cls):
@ -41,6 +110,8 @@ class BaseOrmTest(test.BaseTestCase):
if not CONF.service_available.ranger: if not CONF.service_available.ranger:
skip_msg = ("%s skipped as ranger is not available" % cls.__name__) skip_msg = ("%s skipped as ranger is not available" % cls.__name__)
raise cls.skipException(skip_msg) raise cls.skipException(skip_msg)
# ranger service availability should not be in conf. It should be set
# by ranger pods during deployment to a site.
def assert_expected(self, expected, actual, excluded_keys): def assert_expected(self, expected, actual, excluded_keys):
for key, value in list(expected.items()): for key, value in list(expected.items()):

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

@ -30,7 +30,7 @@ LOG = logging.getLogger(__name__)
class FmsBaseOrmTest(base.BaseOrmTest): class FmsBaseOrmTest(base.BaseOrmTest):
credentials = ['admin', 'primary', 'alt'] credentials = ['admin', 'primary', 'alt']
# added setup_clients function by stew # added setup_clients function by stewie925
@classmethod @classmethod
def setup_clients(cls): def setup_clients(cls):
super(FmsBaseOrmTest, cls).setup_clients() super(FmsBaseOrmTest, cls).setup_clients()
@ -165,12 +165,11 @@ class FmsBaseOrmTest(base.BaseOrmTest):
@classmethod @classmethod
def _del_flv_and_validate_deletion_on_dcp_and_lcp(cls, flavor_id): def _del_flv_and_validate_deletion_on_dcp_and_lcp(cls, flavor_id):
_, body = cls.client.get_flavor(flavor_id) _, body = cls.client.get_flavor(flavor_id)
regions_on_flavor = [region for region in body["flavor"]["regions"]] regions_on_flavor = \
[region['name'] for region in body["flavor"]["regions"]]
if regions_on_flavor: for regs in regions_on_flavor:
region_name_on_flavor = regions_on_flavor[0]["name"]
cls._delete_region_from_flavor_and_validate_deletion( cls._delete_region_from_flavor_and_validate_deletion(
flavor_id, region_name_on_flavor) flavor_id, regs)
cls.client.delete_flavor(flavor_id) cls.client.delete_flavor(flavor_id)
cls._wait_for_flavor_deletion_on_dcp(flavor_id) cls._wait_for_flavor_deletion_on_dcp(flavor_id)
cls._validate_flavor_deletion_on_lcp(flavor_id) cls._validate_flavor_deletion_on_lcp(flavor_id)
@ -178,19 +177,17 @@ class FmsBaseOrmTest(base.BaseOrmTest):
@classmethod @classmethod
def _delete_region_from_flavor_and_validate_deletion( def _delete_region_from_flavor_and_validate_deletion(
cls, flavor_id, rname): cls, flavor_id, rname):
_, body = cls.rms_client.get_region(rname) cls.client.delete_region_from_flavor(flavor_id, rname)
region_id = body["id"]
cls.client.delete_region_from_flavor(flavor_id, region_id)
cls._wait_for_flavor_status_on_dcp(flavor_id, "no regions")
_, body = cls.client.get_flavor(flavor_id)
regions_on_flavor = body["flavor"]["regions"]
if regions_on_flavor: time.sleep(10)
message = \
"Region %s failed to get deleted from flavor %s " % ( _, body = cls.client.get_flavor(flavor_id)
rname, flavor_id) for regions_on_flavor in body['flavor']['regions']:
raise exceptions.TempestException(message) if regions_on_flavor['name'] == rname:
cls._validate_flavor_deletion_on_lcp(flavor_id) message = \
'Region {} failed to get deleted from flavor {}' \
.format(rname, flavor_id)
raise exceptions.TempestException(message)
@classmethod @classmethod
def _wait_for_flavor_deletion_on_dcp(cls, flavor_id): def _wait_for_flavor_deletion_on_dcp(cls, flavor_id):
@ -220,9 +217,9 @@ class FmsBaseOrmTest(base.BaseOrmTest):
@classmethod @classmethod
def _validate_flavor_deletion_on_lcp(cls, flavor_id): def _validate_flavor_deletion_on_lcp(cls, flavor_id):
body = cls.flavors_client.list_flavors()["flavors"] body = cls.flavors_client.list_flavors()["flavors"]
flavor_ids = [flavor["id"] for flavor in body flavor_ids = [flavor["id"] for flavor in body]
if flavor["id"] == flavor_id]
if flavor_ids: if flavor_id in flavor_ids:
flavor_status = cls.flavors_client.show_flavor( flavor_status = cls.flavors_client.show_flavor(
flavor_id)["flavor"]["status"] flavor_id)["flavor"]["status"]
message = "flavor %s failed to get deleted and is in %s status" \ message = "flavor %s failed to get deleted and is in %s status" \

20
ranger_tempest_plugin/tests/api/rms_base.py
View File

@ -17,9 +17,6 @@ from oslo_log import log as logging
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 base from ranger_tempest_plugin.tests.api import base
from tempest import config
CONF = config.CONF
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -32,21 +29,10 @@ class RmsBaseOrmTest(base.BaseOrmTest):
_, cls.region_1 = cls.client.create_region(data_utils.rand_name()) _, cls.region_1 = cls.client.create_region(data_utils.rand_name())
cls.setup_ids.append(cls.region_1['id']) cls.setup_ids.append(cls.region_1['id'])
# create region sharing region_1 properties # create region sharing region_1 properties
_, cls.region_2 = cls.client.create_region(data_utils.rand_name()) _, cls.region_2 = cls.client.create_region(data_utils.rand_name(),
**{'metadata':
{'key': ["value"]}})
cls.setup_ids.append(cls.region_2['id']) cls.setup_ids.append(cls.region_2['id'])
# create region with differing properties
_, cls.region_3 = cls.client.create_region(
data_utils.rand_name(),
**{'status': 'down',
'rangerAgentVersion': '3.0',
'OSVersion': 'mitaka',
'CLLI': '123450',
'address': {'country': 'Mexico', 'state': 'Sonora',
'city': 'Nogales', 'street': '12 main',
'zip': '84000'},
'metadata': {'meta1': ['val1']},
'designType': 'large'})
cls.setup_ids.append(cls.region_3['id'])
for region_id in cls.setup_ids: for region_id in cls.setup_ids:
cls.addClassResourceCleanup(cls.client.delete_region, region_id) cls.addClassResourceCleanup(cls.client.delete_region, region_id)

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

@ -16,7 +16,6 @@
import random import random
import uuid import uuid
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
@ -34,18 +33,11 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
self._wait_for_status(id_, 'no regions') self._wait_for_status(id_, 'no regions')
self.client.delete_customer(id_) self.client.delete_customer(id_)
def _create_region(self, status='functional'): def _update_region(self, region_name, status=None):
region_name = data_utils.rand_name() if status is None:
self.addCleanup( status = {'status': 'functional'}
self.os_admin.rms_client.delete_region, self.os_admin.rms_client.update_region_status(
region_name) region_name, status)
_, region = self.os_admin.rms_client.create_region(
**{
'region_id': region_name,
'status': status,
}
)
return region
def _create_customer(self, post_body): def _create_customer(self, post_body):
customer_id = self._create_cust_validate_creation_on_dcp_and_lcp( customer_id = self._create_cust_validate_creation_on_dcp_and_lcp(
@ -374,53 +366,53 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
@decorators.idempotent_id('b8493b3f-e64d-448e-a965-b0eeff415981') @decorators.idempotent_id('b8493b3f-e64d-448e-a965-b0eeff415981')
def test_customer_while_region_down(self): def test_customer_while_region_down(self):
# create region with status down # create region with status down
region = self._create_region(status='down') self._update_region(CONF.identity.region, status={'status': 'down'})
# create customer within that newly created region # create customer within that newly created region
cust_body = self._get_customer_params() cust_body = self._get_customer_params()
cust_body['regions'][0]['name'] = region['name'] cust_body['regions'][0]['name'] = CONF.identity.region
self.assertRaises(exceptions.BadRequest, self.assertRaises(exceptions.BadRequest,
self.client.create_customer, **cust_body) self.client.create_customer, **cust_body)
@decorators.idempotent_id('1aa52c36-4b1e-459e-9633-12b6cbd53ae7') @decorators.idempotent_id('1aa52c36-4b1e-459e-9633-12b6cbd53ae7')
def test_customer_while_region_building(self): def test_customer_while_region_building(self):
# create region with status building # create region with status maintenance
region = self._create_region(status='building') self._update_region(CONF.identity.region,
region_name = region['name'] status={'status': 'building'})
cust_body = self._get_customer_params() cust_body = self._get_customer_params()
cust_body['regions'][0]['name'] = region['name'] cust_body['regions'][0]['name'] = CONF.identity.region
resp, body = self.client.create_customer(**cust_body) resp, body = self.client.create_customer(**cust_body)
self.assertIn('id', body['customer']) customer_id = body['customer']['id']
test_customer_id = body['customer']['id'] self._wait_for_status(customer_id, 'Success')
self.addCleanup( self.addCleanup(
self._delete_customer, self._delete_customer,
test_customer_id, customer_id,
region_name) CONF.identity.region)
_, body = self.client.get_customer(test_customer_id) _, body = self.client.get_customer(customer_id)
# since region is building it will give error
# Notification to ORD failed self.assertEqual(body['status'], 'Success')
self.assertEqual(body['status'], 'Error') self.assertEqual(body['custId'], customer_id)
self.assertEqual(body['custId'], test_customer_id) self._update_region(CONF.identity.region)
@decorators.idempotent_id('d3cd949e-7895-421c-aeee-2c3d862c391f') @decorators.idempotent_id('d3cd949e-7895-421c-aeee-2c3d862c391f')
def test_customer_while_region_maintenance(self): def test_customer_while_region_maintenance(self):
# create region with status maintenance # create region with status maintenance
region = self._create_region(status='maintenance') self._update_region(CONF.identity.region,
region_name = region['name'] status={'status': 'maintenance'})
cust_body = self._get_customer_params() cust_body = self._get_customer_params()
cust_body['regions'][0]['name'] = region['name'] cust_body['regions'][0]['name'] = CONF.identity.region
resp, body = self.client.create_customer(**cust_body) resp, body = self.client.create_customer(**cust_body)
self.assertIn('id', body['customer']) customer_id = body['customer']['id']
test_customer_id = body['customer']['id'] self._wait_for_status(customer_id, 'Success')
self.addCleanup( self.addCleanup(
self._delete_customer, self._delete_customer,
test_customer_id, customer_id,
region_name) CONF.identity.region)
# since region is maintenance it will give error _, body = self.client.get_customer(customer_id)
# Notification to ORD failed
self.assertEqual(body['status'], 'Error') self.assertEqual(body['status'], 'Success')
self.assertEqual(body['custId'], test_customer_id) self.assertEqual(body['custId'], customer_id)
self._update_region(CONF.identity.region)
@decorators.idempotent_id('49e08cd0-4d33-4ec4-95a0-500974b3a9bf') @decorators.idempotent_id('49e08cd0-4d33-4ec4-95a0-500974b3a9bf')
def test_list_customer_additional_fields(self): def test_list_customer_additional_fields(self):

8
ranger_tempest_plugin/tests/api/test_customers_negative.py
View File

@ -15,10 +15,6 @@
from ranger_tempest_plugin.tests.api import base from ranger_tempest_plugin.tests.api import base
from tempest import config
CONF = config.CONF
class TestTempestCmsNegative(base.BaseOrmTest): class TestTempestCmsNegative(base.BaseOrmTest):
@ -30,14 +26,12 @@ class TestTempestCmsNegative(base.BaseOrmTest):
@classmethod @classmethod
def setup_clients(cls): def setup_clients(cls):
super(TestTempestCmsNegative, cls).setup_clients() super(TestTempestCmsNegative, cls).setup_clients()
cls.client = cls.cmsclient cls.client = cls.os_primary.cms_client
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
cls.set_role_to_admin()
super(TestTempestCmsNegative, cls).resource_setup() super(TestTempestCmsNegative, cls).resource_setup()
@classmethod @classmethod
def resource_cleanup(cls): def resource_cleanup(cls):
cls.delete_role_to_admin()
super(TestTempestCmsNegative, cls).resource_cleanup() super(TestTempestCmsNegative, cls).resource_cleanup()

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

@ -14,7 +14,9 @@
# under the License. # under the License.
import json import json
import time
from oslo_concurrency import lockutils
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
from tempest import config from tempest import config
@ -26,9 +28,15 @@ from tempest.lib.common.utils import data_utils
CONF = config.CONF CONF = config.CONF
PREFIX = 'ranger'
SYNC = lockutils.synchronized_with_prefix(PREFIX)
class TestTempestFms(fms_base.FmsBaseOrmTest): class TestTempestFms(fms_base.FmsBaseOrmTest):
region = CONF.identity.region
region_alt = CONF.ranger.alt_region
@classmethod @classmethod
def setup_credentials(cls): def setup_credentials(cls):
cls.set_network_resources() cls.set_network_resources()
@ -38,11 +46,11 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
def setup_clients(cls): def setup_clients(cls):
super(TestTempestFms, cls).setup_clients() super(TestTempestFms, cls).setup_clients()
cls.rms_client = cls.os_primary.rms_client cls.rms_client = cls.os_primary.rms_client
cls.cms_client = cls.os_primary.cms_client
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
# create flavor for use in test cases
# create flavor then save off flavor_id for use in test cases
body = cls._get_flavor_params() body = cls._get_flavor_params()
cls.addClassResourceCleanup( cls.addClassResourceCleanup(
cls._del_flv_and_validate_deletion_on_dcp_and_lcp, cls._del_flv_and_validate_deletion_on_dcp_and_lcp,
@ -50,31 +58,69 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
cls.flavor = cls._create_flv_and_validate_creation_on_dcp_and_lcp( cls.flavor = cls._create_flv_and_validate_creation_on_dcp_and_lcp(
**body) **body)
# these variables will be used to test list filters cls.tenant_id = cls._create_customer()
cls.flavor_id = cls.flavor['id'] cls.alt_tenant_id = cls._create_customer()
cls.flavor_name = cls.flavor['name']
cls.visibility = cls.flavor['visibility']
cls.series = cls.flavor['series']
cls.tenant_id = cls.tenant_id
cls.region_id = CONF.identity.region
cls.alias = cls.flavor['alias']
cls.dflt_ex_specs = cls.flavor['extra-specs']
cls.tags = cls.flavor['tag']
# add custom extra specs # add custom extra specs
cls.custom_es = {'os_extra_specs': {'g': 'guava', 'h': 'honeydew'}} cls.custom_es = {'os_extra_specs': {'g': 'guava', 'h': 'honeydew'}}
cls.client.add_extra_specs(cls.flavor_id, cls.custom_es) cls.client.add_extra_specs(cls.flavor['id'], cls.custom_es)
cls._wait_for_flavor_status_on_dcp(cls.flavor_id, 'Success') cls._wait_for_flavor_status_on_dcp(cls.flavor['id'], 'Success')
# build customers for related flavor tests
super(TestTempestFms, cls).resource_setup() super(TestTempestFms, cls).resource_setup()
@classmethod
def _create_customer(cls):
cust = {}
cust['description'] = ''
cust['enabled'] = True
cust['name'] = data_utils.rand_name('ormTempestFms')
cust['regions'] = [{'name': CONF.identity.region, 'type': 'single'}]
cust['defaultQuotas'] = []
cust['users'] = []
_, body = cls.cms_client.create_customer(**cust)
customer_id = body["customer"]["id"]
_, customer = cls.cms_client.get_customer(customer_id)
if customer["name"] == cust["name"]:
if customer["regions"] == []:
customer_status = "no regions"
else:
customer_status = "Success"
else:
message = "customer %s not created successfully" % cust["name"]
exceptions.TempestException(message)
customer_status = cls.cms_client.get_customer(customer_id)[1]["status"]
start = int(time.time())
while customer_status != 'Success':
time.sleep(cls.build_interval)
customer_status = \
cls.cms_client.get_customer(customer_id)[1]["status"]
if customer_status == 'Error':
message = ('customer %s failed to reach %s status'
' and is in ERROR status on orm' %
(customer_id, customer_status))
raise exceptions.TempestException(message)
if int(time.time()) - start >= cls.build_timeout:
message = ('customer %s failed to reach %s'
'status within the required time (%s s)'
'on orm and is in %s status.'
% (customer_id, customer_status,
cls.build_timeout,
customer_status))
return customer_id
def _get_flavor_details(self, flavor_id): def _get_flavor_details(self, flavor_id):
_, body = self.client.get_flavor(flavor_id) _, body = self.client.get_flavor(flavor_id)
return body["flavor"] return body["flavor"]
def _create_region_group(self): def _create_region_group(self):
_, body = self.rms_client.create_region_group( _, body = self.rms_client.create_region_group(
**orm_data_utils.rand_region_group([CONF.identity.region]) **orm_data_utils.rand_region_group([self.region,
self.region_alt])
) )
group_id = body['group']['id'] group_id = body['group']['id']
self.addCleanup( self.addCleanup(
@ -124,7 +170,7 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
_, extra_specs = self.client.get_extra_specs(flavor_id) _, extra_specs = self.client.get_extra_specs(flavor_id)
es_expected = self.custom_es.get("os_extra_specs") es_expected = self.custom_es.get("os_extra_specs")
es_expected.update(self.dflt_ex_specs) es_expected.update(self.flavor['extra-specs'])
self.assertDictEqual(es_expected, extra_specs.get("os_extra_specs")) self.assertDictEqual(es_expected, extra_specs.get("os_extra_specs"))
def _assert_create_flavor(self, public=False): def _assert_create_flavor(self, public=False):
@ -142,32 +188,26 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
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 _update_region(self, r_name, status=None):
region_name = data_utils.rand_name() if status is None:
self.addCleanup( status = {'status': 'functional'}
self.os_admin.rms_client.delete_region, self.os_admin.rms_client.update_region_status(
region_name) r_name, status=status)
_, region = self.os_admin.rms_client.create_region(
**{
'region_id': region_name,
'status': status,
}
)
return region
def _delete_flavor(self, flavor_id): def _delete_flavor(self, flavor_id):
# delete the data and do get_flavor to ensure 404-NotFound response # delete the data and get_flavor to ensure 404-NotFound response
self._del_flv_and_validate_deletion_on_dcp_and_lcp(flavor_id) self._del_flv_and_validate_deletion_on_dcp_and_lcp(flavor_id)
self.assertRaises(exceptions.NotFound, self.assertRaises(exceptions.NotFound,
self.client.get_flavor, self.client.get_flavor,
flavor_id) flavor_id)
@SYNC('flavor')
@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):
"""Execute get_flavor using flavor_id / flavor_name""" """Execute get_flavor using flavor_id / flavor_name"""
for para in [self.flavor_id, self.flavor_name]: for para in [self.flavor['id'], self.flavor['name']]:
_, body = self.client.get_flavor(para) _, body = self.client.get_flavor(para)
self.assertIn(self.flavor_id, body["flavor"]["id"]) self.assertIn(self.flavor['id'], body["flavor"]["id"])
@decorators.idempotent_id('c46a503a-951c-4d00-afaa-46076b54db16') @decorators.idempotent_id('c46a503a-951c-4d00-afaa-46076b54db16')
def test_list_flavor_with_filters(self): def test_list_flavor_with_filters(self):
@ -182,27 +222,30 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
- 'series' filter - 'series' filter
- "tenant" filter - "tenant" filter
""" """
post_body = self._get_flavor_params()
flavor = self._data_setup(post_body)
# for use by the 'constains and 'starts_with' filter # for use by the 'constains and 'starts_with' filter
str_index1 = data_utils.rand_int_id(0, len(self.flavor_name) - 1) str_index1 = data_utils.rand_int_id(0, len(flavor['name']) - 1)
str_index2 = data_utils.rand_int_id(str_index1 + 1, str_index2 = data_utils.rand_int_id(str_index1 + 1,
len(self.flavor_name)) len(flavor['name']))
# define the list flavors filters to be used for this test # define the list flavors filters to be used for this test
alias_filter = "?alias=%s" % self.alias alias_filter = "?alias=%s" % flavor['alias']
region_filter = "?region=%s" % self.region_id region_filter = "?region=%s" % CONF.identity.region
visibility_filter = "?visibility=%s" % self.visibility visibility_filter = "?visibility=%s" % flavor['visibility']
contains_filter = '?contains=%s' \ contains_filter = '?contains=%s' \
% self.flavor_name[str_index1:str_index2] % flavor['name'][str_index1:str_index2]
startswith_filter = "?starts_with=%s" % self.flavor_name[:str_index2] startswith_filter = "?starts_with=%s" % flavor['name'][:str_index2]
series_filter = "?series=%s" % self.series series_filter = "?series=%s" % flavor['series']
tenant_filter = "?tenant=%s" % self.tenant_id tenant_filter = "?tenant=%s" % self.tenant_id
for list_filter in [None, region_filter, visibility_filter, for list_filter in [None, region_filter, visibility_filter,
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 = [flavor["id"] for flavor in body["flavors"]] flavor_ids = [test_flavor["id"] for test_flavor in body["flavors"]]
self.assertIn(self.flavor_id, flavor_ids) self.assertIn(flavor['id'], flavor_ids)
@decorators.idempotent_id('7b9d1f91-a8a4-458d-aaad-a98b5bf033b4') @decorators.idempotent_id('7b9d1f91-a8a4-458d-aaad-a98b5bf033b4')
def test_create_private_flavor(self): def test_create_private_flavor(self):
@ -212,60 +255,69 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
def test_create_public_flavor(self): def test_create_public_flavor(self):
self._assert_create_flavor(public=True) self._assert_create_flavor(public=True)
@SYNC('flavor')
@decorators.idempotent_id('4cad10ce-67d2-4633-b347-2c16783a31b9') @decorators.idempotent_id('4cad10ce-67d2-4633-b347-2c16783a31b9')
def test_add_flavor_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)
_, tag_body = self.client.get_tags(self.flavor_id) _, tag_body = self.client.get_tags(self.flavor['id'])
subset = {k: v for k, v in list(tag_body.get("tags").items()) subset = {k: v for k, v in list(tag_body.get("tags").items())
if k in add_tag_body.get("tags")} if k in add_tag_body.get("tags")}
self.assertDictEqual(add_tag_body.get("tags"), subset) self.assertDictEqual(add_tag_body.get("tags"), subset)
@SYNC('flavor')
@decorators.idempotent_id('db8e5c0f-0041-45d4-9939-e079296123d8') @decorators.idempotent_id('db8e5c0f-0041-45d4-9939-e079296123d8')
def test_replace_flavor_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)
_, 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"))
@SYNC('flavor')
@decorators.idempotent_id('e0a0eca6-e120-45ab-a1a4-f5b95fdf97f1') @decorators.idempotent_id('e0a0eca6-e120-45ab-a1a4-f5b95fdf97f1')
def test_delete_flavor_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',
delete_tag_key) delete_tag_key)
# do get_tag and tries to retrieve the deleted tag # do get_tag and tries to retrieve the deleted tag
_, tag_body = self.client.get_tags(self.flavor_id) _, tag_body = self.client.get_tags(self.flavor['id'])
tag_present = tag_body.get("tags").get(delete_tag_key, None) tag_present = tag_body.get("tags").get(delete_tag_key, None)
self.assertIsNone(tag_present) self.assertIsNone(tag_present)
@SYNC('flavor')
@decorators.idempotent_id('9c511020-53ed-4139-8c53-451cb0ea8c75') @decorators.idempotent_id('9c511020-53ed-4139-8c53-451cb0ea8c75')
def test_delete_all_flavor_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'])
restore_tags = tag_body
self.assertTrue(True if tag_body.get("tags") else False) self.assertTrue(True if tag_body.get("tags") else False)
# 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)
_, 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"])
# restore deleted tags
self._exec_tags_function(self.flavor['id'], restore_tags, 'add', None)
@decorators.idempotent_id('ec74d68f-b42a-41a8-9685-ff5eca25ea0c') @decorators.idempotent_id('ec74d68f-b42a-41a8-9685-ff5eca25ea0c')
def test_add_delete_flavor_region(self): def test_add_delete_flavor_region(self):
# setup data to add region # setup data to add region
region_id = CONF.identity.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_flavor_id = flavor['id'] test_flavor_id = flavor['id']
post_region_body = '{"regions": [{"name": "%s"}]}' % (self.region_id) post_region_body = '{"regions": [{"name": "%s"}]}' % (region_id)
post_region_body = json.loads(post_region_body) post_region_body = json.loads(post_region_body)
_, body = self.client.add_flavor_regions(test_flavor_id, _, body = self.client.add_flavor_regions(test_flavor_id,
post_region_body) post_region_body)
@ -276,72 +328,81 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
# remove added region and then check to confirm flavor status # remove added region and then check to confirm flavor status
_, body = self.client.delete_flavor_region(test_flavor_id, _, body = self.client.delete_flavor_region(test_flavor_id,
self.region_id) 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_flavor_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_flavor_id) _, body = self.client.get_flavor(test_flavor_id)
self.assertTrue(len(body["flavor"]["regions"]) == 0) self.assertTrue(len(body["flavor"]["regions"]) == 0)
@SYNC('flavor')
@decorators.idempotent_id('71404409-5d95-472c-8dac-b49a1c0c4b37') @decorators.idempotent_id('71404409-5d95-472c-8dac-b49a1c0c4b37')
def test_add_flavor_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")
# add custom extra specs # add custom extra specs
add_es_body = {"os_extra_specs": {"a": "apple", "b": "banana"}} add_es_body = {"os_extra_specs": {"a": "apple", "b": "banana"}}
self._exec_ex_spec_function(self.flavor_id, add_es_body, 'add', None) self._exec_ex_spec_function(self.flavor['id'],
_, extra_specs = self.client.get_extra_specs(self.flavor_id) add_es_body,
'add', None)
_, extra_specs = self.client.get_extra_specs(self.flavor['id'])
# assert extra specs add results match expected # assert extra specs add results match expected
es_expected.update(add_es_body["os_extra_specs"]) es_expected.update(add_es_body["os_extra_specs"])
self.assertDictEqual(es_expected, extra_specs.get("os_extra_specs")) self.assertDictEqual(es_expected, extra_specs.get("os_extra_specs"))
@SYNC('flavor')
@decorators.idempotent_id('043948fd-125b-4d96-bf40-42464066a7e1') @decorators.idempotent_id('043948fd-125b-4d96-bf40-42464066a7e1')
def test_update_flavor_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(
self.flavor_id, self.flavor['id'],
replace_es_body, replace_es_body,
'update', 'update',
None) None)
# assert extra specs update results match expected # assert extra specs update results match expected
_, flavor_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.flavor['extra-specs'])
self.assertDictEqual(es_expected, self.assertDictEqual(es_expected,
flavor_ex_specs.get("os_extra_specs")) flavor_ex_specs.get("os_extra_specs"))
@SYNC('flavor')
@decorators.idempotent_id('df83e2cd-d202-4b2f-8459-391a73067ec5') @decorators.idempotent_id('df83e2cd-d202-4b2f-8459-391a73067ec5')
def test_delete_flavor_extra_spec(self): def test_create_and_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'])
# now delete one of the custom extra specs # now delete one of the custom extra specs
delete_es_key_h = "h" delete_es_key_h = "h"
self._exec_ex_spec_function(self.flavor_id, None, 'delete', self._exec_ex_spec_function(self.flavor['id'], None, 'delete',
delete_es_key_h) delete_es_key_h)
# 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)
_, flavor_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"],
flavor_ex_specs.get("os_extra_specs")) flavor_ex_specs.get("os_extra_specs"))
@SYNC('flavor')
@decorators.idempotent_id('e3fc7ce3-c8fe-4805-8ad3-7be2c94fe7ad') @decorators.idempotent_id('e3fc7ce3-c8fe-4805-8ad3-7be2c94fe7ad')
def test_delete_all_flavor_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) _, specs_to_restore = self.client.get_extra_specs(self.flavor['id'])
_, flavor_ex_specs = self.client.get_extra_specs(self.flavor_id) self._exec_ex_spec_function(self.flavor['id'], None, 'delete', None)
_, flavor_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.flavor['extra-specs'],
flavor_ex_specs.get("os_extra_specs")) flavor_ex_specs.get("os_extra_specs"))
self._exec_ex_spec_function(self.flavor['id'],
specs_to_restore, 'add', None)
@decorators.idempotent_id('187195b5-adfb-4c73-a2f5-42117021f5f2') @decorators.idempotent_id('187195b5-adfb-4c73-a2f5-42117021f5f2')
def test_add_delete_flavor_tenant(self): def test_add_delete_flavor_tenant(self):
@ -356,10 +417,10 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
self.assertEqual(flavor["tenants"][0], self.tenant_id) self.assertEqual(flavor["tenants"][0], self.tenant_id)
# test add_flavor_tenant by adding one more tenant # test add_flavor_tenant by adding one more tenant
post_tenant_body = '{"tenants": ["%s"]}' % (self.alt_tenant_id) alt_tenant_body = '{"tenants": ["%s"]}' % (self.alt_tenant_id)
post_tenant_body = json.loads(post_tenant_body) alt_tenant_body = json.loads(alt_tenant_body)
_, body = self.client.add_flavor_tenants(test_flavor_id, _, body = self.client.add_flavor_tenants(test_flavor_id,
post_tenant_body) alt_tenant_body)
self._wait_for_flavor_status_on_dcp(test_flavor_id, 'Success') 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
@ -380,16 +441,14 @@ 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()
self.addCleanup(
self._del_flv_and_validate_deletion_on_dcp_and_lcp,
post_body['id'])
flavor = self._create_flv_and_validate_creation_on_dcp_and_lcp( flavor = self._create_flv_and_validate_creation_on_dcp_and_lcp(
**post_body) **post_body)
test_flavor_id = 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(flavor['id'])
self.assertRaises(exceptions.NotFound, self.client.get_flavor, self.assertRaises(exceptions.NotFound, self.client.get_flavor,
test_flavor_id) 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):
@ -461,25 +520,22 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
@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.alt_region if not self.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')
post_body = self._get_flavor_params() post_body = self._get_flavor_params()
post_body['regions'].append( post_body['regions'].append(
{'name': region_alt} {'name': self.region_alt}
) )
flavor = self._data_setup(post_body) flavor = self._data_setup(post_body)
test_flavor_id = flavor['id'] test_flavor_id = flavor['id']
flavor_details = self._get_flavor_details(test_flavor_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(len(flavor['regions']), 2)
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_group_region(self):
region_alt = CONF.ranger.alt_region if not self.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')
group_id = self._create_region_group() group_id = self._create_region_group()
@ -487,18 +543,14 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
post_body['regions'] = [ post_body['regions'] = [
{ {
'name': group_id, 'name': group_id,
'type': 'group', 'type': 'group'
},
{
'name': region_alt,
'type': 'single',
} }
] ]
flavor = self._data_setup(post_body) flavor = self._data_setup(post_body)
flavor_details = self._get_flavor_details(flavor['id']) flavor_details = self._get_flavor_details(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'], self.region)
self.assertEqual(flavor['regions'][1]['name'], region_alt) self.assertEqual(flavor['regions'][1]['name'], self.region_alt)
@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):
@ -510,25 +562,22 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
@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):
# create region with status down # update region to status down
region = self._create_region(status='down') self._update_region(self.region, status={'status': 'down'})
# create flavor within that newly created region # create flavor within that newly created region
post_body = self._get_flavor_params() post_body = self._get_flavor_params(set_region=False)
post_body['regions'][0]['name'] = region['name'] post_body['regions'] = [{'name': self.region}]
self.assertRaises(exceptions.BadRequest, self.assertRaises(exceptions.BadRequest,
self._data_setup, post_body) self.client.create_flavor, **post_body)
self._update_region(self.region)
@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):
# create region with status building # update region to status building
region = self._create_region(status='building') self._update_region(self.region, status={'status': 'building'})
post_body = self._get_flavor_params(set_region=False)
post_body = self._get_flavor_params() post_body['regions'] = [{'name': self.region}]
post_body['regions'][0]['name'] = region['name']
self.addCleanup(
self._delete_flavor,
post_body['id'])
body = self._data_setup(post_body) body = self._data_setup(post_body)
self.assertIn('id', body) self.assertIn('id', body)
@ -536,19 +585,21 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
flavor = self._get_flavor_details(test_flavor_id) flavor = self._get_flavor_details(test_flavor_id)
self.assertEqual(flavor['id'], test_flavor_id) self.assertEqual(flavor['id'], test_flavor_id)
self.assertEqual(flavor['status'], 'Error') self.assertEqual(flavor['status'], 'Success')
self._update_region(self.region)
@decorators.idempotent_id('e17dab64-c900-4a19-a7a2-96a0bf4af0f8') @decorators.idempotent_id('e17dab64-c900-4a19-a7a2-96a0bf4af0f8')
def test_flavor_while_region_maintenance(self): def test_flavor_while_region_maintenance(self):
# create region with status maintenance # update region to status maintenance
region = self._create_region(status='maintenance') self._update_region(self.region, status={'status': 'maintenance'})
post_body = self._get_flavor_params() post_body = self._get_flavor_params(set_region=False)
post_body['regions'][0]['name'] = region['name'] post_body['regions'] = [{'name': self.region}]
body = self._data_setup(post_body) body = self._data_setup(post_body)
self.assertIn('id', body) self.assertIn('id', body)
test_flavor_id = body['id'] test_flavor_id = body['id']
flavor = self._get_flavor_details(test_flavor_id) flavor = self._get_flavor_details(test_flavor_id)
self.assertEqual(flavor['id'], test_flavor_id) self.assertEqual(flavor['id'], test_flavor_id)
self.assertEqual(flavor['status'], 'Error') self.assertEqual(flavor['status'], 'Success')
self._update_region(self.region)

10
ranger_tempest_plugin/tests/api/test_flavors_negative.py
View File

@ -15,10 +15,6 @@
from ranger_tempest_plugin.tests.api import base from ranger_tempest_plugin.tests.api import base
from tempest import config
CONF = config.CONF
class TestTempestFmsNegative(base.BaseOrmTest): class TestTempestFmsNegative(base.BaseOrmTest):
@ -30,16 +26,12 @@ class TestTempestFmsNegative(base.BaseOrmTest):
@classmethod @classmethod
def setup_clients(cls): def setup_clients(cls):
super(TestTempestFmsNegative, cls).setup_clients() super(TestTempestFmsNegative, cls).setup_clients()
cls.client = cls.fmsclient cls.client = cls.os_primary.fms_client
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
cls.set_role_to_admin()
super(TestTempestFmsNegative, cls).resource_setup() super(TestTempestFmsNegative, cls).resource_setup()
cls.env_name = cls.env_name
cls.tenant_id = cls.tenant_id
@classmethod @classmethod
def resource_cleanup(cls): def resource_cleanup(cls):
cls.delete_role_to_admin()
super(TestTempestFmsNegative, cls).resource_cleanup() super(TestTempestFmsNegative, cls).resource_cleanup()

14
ranger_tempest_plugin/tests/api/test_images.py
View File

@ -89,8 +89,18 @@ class TestTempestIms(ims_base.ImsBaseOrmTest):
**{ **{
'region_id': region_name, 'region_id': region_name,
'status': status, 'status': status,
} 'endpoints': [{
) 'publicURL':
'https://dashboard-ranger.%s.com' % region_name,
'type': 'dashboard'
}, {
'publicURL': CONF.identity.uri_v3,
'type': 'identity'
}, {
'publicURL':
'https://ranger-agent.%s.com:9010' % region_name,
'type': 'ord'
}]})
return region return region

13
ranger_tempest_plugin/tests/api/test_images_negative.py
View File

@ -15,10 +15,6 @@
from ranger_tempest_plugin.tests.api import base from ranger_tempest_plugin.tests.api import base
from tempest import config
CONF = config.CONF
class TestTempestImsNegative(base.BaseOrmTest): class TestTempestImsNegative(base.BaseOrmTest):
@ -30,19 +26,12 @@ class TestTempestImsNegative(base.BaseOrmTest):
@classmethod @classmethod
def setup_clients(cls): def setup_clients(cls):
super(TestTempestImsNegative, cls).setup_clients() super(TestTempestImsNegative, cls).setup_clients()
cls.client = cls.imsclient cls.client = cls.os_primary.ims_client
cls.servers_client = cls.servers_client
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
cls.set_role_to_admin()
super(TestTempestImsNegative, cls).resource_setup() super(TestTempestImsNegative, cls).resource_setup()
cls.env_name = cls.env_name
cls.tenant_id = cls.tenant_id
cls.flavor_ref = CONF.compute.flavor_ref
cls.network_ref = CONF.network.public_network_id
@classmethod @classmethod
def resource_cleanup(cls): def resource_cleanup(cls):
cls.delete_role_to_admin()
super(TestTempestImsNegative, cls).resource_cleanup() super(TestTempestImsNegative, cls).resource_cleanup()

4
ranger_tempest_plugin/tests/api/test_region_groups.py
View File

@ -16,15 +16,11 @@
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 base from ranger_tempest_plugin.tests.api import base
from tempest import config
from tempest.lib import decorators from tempest.lib import decorators
from tempest.lib import exceptions from tempest.lib import exceptions
from tempest.lib.common.utils import data_utils from tempest.lib.common.utils import data_utils
CONF = config.CONF
class TestTempestRegionGroup(base.BaseOrmTest): class TestTempestRegionGroup(base.BaseOrmTest):

8
ranger_tempest_plugin/tests/api/test_regiongroups_negative.py
View File

@ -15,10 +15,6 @@
from ranger_tempest_plugin.tests.api import base from ranger_tempest_plugin.tests.api import base
from tempest import config
CONF = config.CONF
class TestTempestRegGroupNegative(base.BaseOrmTest): class TestTempestRegGroupNegative(base.BaseOrmTest):
@ -30,14 +26,12 @@ class TestTempestRegGroupNegative(base.BaseOrmTest):
@classmethod @classmethod
def setup_clients(cls): def setup_clients(cls):
super(TestTempestRegGroupNegative, cls).setup_clients() super(TestTempestRegGroupNegative, cls).setup_clients()
cls.client = cls.rmsclient cls.client = cls.os_primary.rms_client
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
cls.set_role_to_admin()
super(TestTempestRegGroupNegative, cls).resource_setup() super(TestTempestRegGroupNegative, cls).resource_setup()
@classmethod @classmethod
def resource_cleanup(cls): def resource_cleanup(cls):
cls.delete_role_to_admin()
super(TestTempestRegGroupNegative, cls).resource_cleanup() super(TestTempestRegGroupNegative, cls).resource_cleanup()

16
ranger_tempest_plugin/tests/api/test_regions.py
View File

@ -16,15 +16,9 @@
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 rms_base from ranger_tempest_plugin.tests.api import rms_base
from tempest import config
from tempest.lib import decorators from tempest.lib import decorators
from tempest.lib import exceptions from tempest.lib import exceptions
from tempest.lib.common.utils import data_utils
CONF = config.CONF
class TestTempestRegion(rms_base.RmsBaseOrmTest): class TestTempestRegion(rms_base.RmsBaseOrmTest):
@ -108,13 +102,13 @@ class TestTempestRegion(rms_base.RmsBaseOrmTest):
@decorators.idempotent_id('358f3cbc-4ae5-4b43-be36-6df55eae8fd9') @decorators.idempotent_id('358f3cbc-4ae5-4b43-be36-6df55eae8fd9')
def test_get_region(self): def test_get_region(self):
_, body = self.client.get_region(self.region_1['id']) _, body = self.client.get_region(self.region_2['id'])
self.assert_expected(self.region_1, body, []) self.assert_expected(self.region_2, body, [])
@decorators.idempotent_id('cefb952f-7777-4878-87d2-d78ac345f0d2') @decorators.idempotent_id('cefb952f-7777-4878-87d2-d78ac345f0d2')
def test_get_region_metadata(self): def test_get_region_metadata(self):
_, body = self.client.get_region_metadata(self.region_1['id']) _, body = self.client.get_region_metadata(self.region_2['id'])
self.assert_expected(self.region_1['metadata'], body['metadata'], []) self.assert_expected({'metadata': {'key': ['value']}}, body, [])
@decorators.idempotent_id('b2c3baf5-22af-4bf9-bcad-b6a1a74e82d9') @decorators.idempotent_id('b2c3baf5-22af-4bf9-bcad-b6a1a74e82d9')
def test_update_region(self): def test_update_region(self):
@ -130,6 +124,8 @@ class TestTempestRegion(rms_base.RmsBaseOrmTest):
[self.region_1['status']]) [self.region_1['status']])
_, body = self.client.update_region_status(self.region_1['id'], status) _, body = self.client.update_region_status(self.region_1['id'], status)
self.assert_expected(status, body, ['links']) self.assert_expected(status, body, ['links'])
status['status'] = 'functional'
_, body = self.client.update_region_status(self.region_1['id'], status)
@decorators.idempotent_id('5c1a2624-6abe-49e7-82c8-30e8df1377d0') @decorators.idempotent_id('5c1a2624-6abe-49e7-82c8-30e8df1377d0')
def test_update_region_metadata(self): def test_update_region_metadata(self):

8
ranger_tempest_plugin/tests/api/test_regions_negative.py
View File

@ -15,10 +15,6 @@
from ranger_tempest_plugin.tests.api import base from ranger_tempest_plugin.tests.api import base
from tempest import config
CONF = config.CONF
class TestTempestRegionsNegative(base.BaseOrmTest): class TestTempestRegionsNegative(base.BaseOrmTest):
@ -30,14 +26,12 @@ class TestTempestRegionsNegative(base.BaseOrmTest):
@classmethod @classmethod
def setup_clients(cls): def setup_clients(cls):
super(TestTempestRegionsNegative, cls).setup_clients() super(TestTempestRegionsNegative, cls).setup_clients()
cls.client = cls.rmsclient cls.client = cls.os_primary.rms_client
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
cls.set_role_to_admin()
super(TestTempestRegionsNegative, cls).resource_setup() super(TestTempestRegionsNegative, cls).resource_setup()
@classmethod @classmethod
def resource_cleanup(cls): def resource_cleanup(cls):
cls.delete_role_to_admin()
super(TestTempestRegionsNegative, cls).resource_cleanup() super(TestTempestRegionsNegative, cls).resource_cleanup()