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 LANG C.UTF-8
RUN apt update && \
apt -y install git \
RUN apt -qq update && \
apt -qq -y install git \
netcat \
netbase \
openssh-server \
@ -45,7 +45,7 @@ WORKDIR /
COPY . ranger-tempest-plugin/
WORKDIR /ranger-tempest-plugin/
RUN python setup.py develop
RUN python3 setup.py develop
##########################################################################
### END OF ranger-tempest-plugin setup
@ -58,25 +58,15 @@ RUN python setup.py develop
### reset workdir to root before executing tempest steps
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
RUN mkdir -p /tempest/logs \
&& mkdir -p /etc/tempest \
&& mkdir -p /tempest/tempest_lock \
&& mkdir -p /tempest/images \
&& mkdir -p /var/log/tempest \
&& rm -rf /tempest/.stestr \
&& rm -rf /tempest/.stestr.conf
&& mkdir -p /var/log/tempest
# copy tempest test setup files
COPY tempest_setup/create_tenant.sh /tempest/etc
COPY tempest_setup/accounts.yaml /tempest/etc
COPY tempest_setup/tempest.conf /tempest/etc
COPY tempest_setup/tempest.conf /etc/tempest
##########################################################################
### END OF openstack tempest setup steps
@ -86,9 +76,8 @@ COPY tempest_setup/tempest.conf /tempest/etc
### RUN tempest tests on test_regions
##########################################################################
### 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 \
# && /bin/bash
#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']
except Exception as ex:
raise ConnectionError(ex.message)
raise ConnectionError(str(ex))
def get_headers(self, accept_type=None, send_type=None):
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
credentials = ['admin', 'primary', 'alt']
identity_url = CONF.identity.uri_v3 or ""
identity_url = identity_url.strip('/v3')
build_timeout = 120
build_interval = 10
@ -34,6 +35,74 @@ class BaseOrmTest(test.BaseTestCase):
def setup_clients(cls):
super(BaseOrmTest, cls).setup_clients()
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
def skip_checks(cls):
@ -41,6 +110,8 @@ class BaseOrmTest(test.BaseTestCase):
if not CONF.service_available.ranger:
skip_msg = ("%s skipped as ranger is not available" % cls.__name__)
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):
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):
credentials = ['admin', 'primary', 'alt']
# added setup_clients function by stew
# added setup_clients function by stewie925
@classmethod
def setup_clients(cls):
super(FmsBaseOrmTest, cls).setup_clients()
@ -165,12 +165,11 @@ class FmsBaseOrmTest(base.BaseOrmTest):
@classmethod
def _del_flv_and_validate_deletion_on_dcp_and_lcp(cls, flavor_id):
_, body = cls.client.get_flavor(flavor_id)
regions_on_flavor = [region for region in body["flavor"]["regions"]]
if regions_on_flavor:
region_name_on_flavor = regions_on_flavor[0]["name"]
regions_on_flavor = \
[region['name'] for region in body["flavor"]["regions"]]
for regs in regions_on_flavor:
cls._delete_region_from_flavor_and_validate_deletion(
flavor_id, region_name_on_flavor)
flavor_id, regs)
cls.client.delete_flavor(flavor_id)
cls._wait_for_flavor_deletion_on_dcp(flavor_id)
cls._validate_flavor_deletion_on_lcp(flavor_id)
@ -178,19 +177,17 @@ class FmsBaseOrmTest(base.BaseOrmTest):
@classmethod
def _delete_region_from_flavor_and_validate_deletion(
cls, flavor_id, rname):
_, body = cls.rms_client.get_region(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"]
cls.client.delete_region_from_flavor(flavor_id, rname)
if regions_on_flavor:
message = \
"Region %s failed to get deleted from flavor %s " % (
rname, flavor_id)
raise exceptions.TempestException(message)
cls._validate_flavor_deletion_on_lcp(flavor_id)
time.sleep(10)
_, body = cls.client.get_flavor(flavor_id)
for regions_on_flavor in body['flavor']['regions']:
if regions_on_flavor['name'] == rname:
message = \
'Region {} failed to get deleted from flavor {}' \
.format(rname, flavor_id)
raise exceptions.TempestException(message)
@classmethod
def _wait_for_flavor_deletion_on_dcp(cls, flavor_id):
@ -220,9 +217,9 @@ class FmsBaseOrmTest(base.BaseOrmTest):
@classmethod
def _validate_flavor_deletion_on_lcp(cls, flavor_id):
body = cls.flavors_client.list_flavors()["flavors"]
flavor_ids = [flavor["id"] for flavor in body
if flavor["id"] == flavor_id]
if flavor_ids:
flavor_ids = [flavor["id"] for flavor in body]
if flavor_id in flavor_ids:
flavor_status = cls.flavors_client.show_flavor(
flavor_id)["flavor"]["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.tests.api import base
from tempest import config
CONF = config.CONF
LOG = logging.getLogger(__name__)
@ -32,21 +29,10 @@ class RmsBaseOrmTest(base.BaseOrmTest):
_, cls.region_1 = cls.client.create_region(data_utils.rand_name())
cls.setup_ids.append(cls.region_1['id'])
# 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'])
# 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:
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 uuid
from ranger_tempest_plugin.data_utils import data_utils
from ranger_tempest_plugin.tests.api import cms_base
from tempest import config
@ -34,18 +33,11 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
self._wait_for_status(id_, 'no regions')
self.client.delete_customer(id_)
def _create_region(self, status='functional'):
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_id': region_name,
'status': status,
}
)
return region
def _update_region(self, region_name, status=None):
if status is None:
status = {'status': 'functional'}
self.os_admin.rms_client.update_region_status(
region_name, status)
def _create_customer(self, post_body):
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')
def test_customer_while_region_down(self):
# 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
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.client.create_customer, **cust_body)
@decorators.idempotent_id('1aa52c36-4b1e-459e-9633-12b6cbd53ae7')
def test_customer_while_region_building(self):
# create region with status building
region = self._create_region(status='building')
region_name = region['name']
# create region with status maintenance
self._update_region(CONF.identity.region,
status={'status': 'building'})
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)
self.assertIn('id', body['customer'])
test_customer_id = body['customer']['id']
customer_id = body['customer']['id']
self._wait_for_status(customer_id, 'Success')
self.addCleanup(
self._delete_customer,
test_customer_id,
region_name)
_, body = self.client.get_customer(test_customer_id)
# since region is building it will give error
# Notification to ORD failed
self.assertEqual(body['status'], 'Error')
self.assertEqual(body['custId'], test_customer_id)
customer_id,
CONF.identity.region)
_, body = self.client.get_customer(customer_id)
self.assertEqual(body['status'], 'Success')
self.assertEqual(body['custId'], customer_id)
self._update_region(CONF.identity.region)
@decorators.idempotent_id('d3cd949e-7895-421c-aeee-2c3d862c391f')
def test_customer_while_region_maintenance(self):
# create region with status maintenance
region = self._create_region(status='maintenance')
region_name = region['name']
self._update_region(CONF.identity.region,
status={'status': 'maintenance'})
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)
self.assertIn('id', body['customer'])
test_customer_id = body['customer']['id']
customer_id = body['customer']['id']
self._wait_for_status(customer_id, 'Success')
self.addCleanup(
self._delete_customer,
test_customer_id,
region_name)
# since region is maintenance it will give error
# Notification to ORD failed
self.assertEqual(body['status'], 'Error')
self.assertEqual(body['custId'], test_customer_id)
customer_id,
CONF.identity.region)
_, body = self.client.get_customer(customer_id)
self.assertEqual(body['status'], 'Success')
self.assertEqual(body['custId'], customer_id)
self._update_region(CONF.identity.region)
@decorators.idempotent_id('49e08cd0-4d33-4ec4-95a0-500974b3a9bf')
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 tempest import config
CONF = config.CONF
class TestTempestCmsNegative(base.BaseOrmTest):
@ -30,14 +26,12 @@ class TestTempestCmsNegative(base.BaseOrmTest):
@classmethod
def setup_clients(cls):
super(TestTempestCmsNegative, cls).setup_clients()
cls.client = cls.cmsclient
cls.client = cls.os_primary.cms_client
@classmethod
def resource_setup(cls):
cls.set_role_to_admin()
super(TestTempestCmsNegative, cls).resource_setup()
@classmethod
def resource_cleanup(cls):
cls.delete_role_to_admin()
super(TestTempestCmsNegative, cls).resource_cleanup()

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

@ -14,7 +14,9 @@
# under the License.
import json
import time
from oslo_concurrency import lockutils
from ranger_tempest_plugin import data_utils as orm_data_utils
from ranger_tempest_plugin.tests.api import fms_base
from tempest import config
@ -26,9 +28,15 @@ from tempest.lib.common.utils import data_utils
CONF = config.CONF
PREFIX = 'ranger'
SYNC = lockutils.synchronized_with_prefix(PREFIX)
class TestTempestFms(fms_base.FmsBaseOrmTest):
region = CONF.identity.region
region_alt = CONF.ranger.alt_region
@classmethod
def setup_credentials(cls):
cls.set_network_resources()
@ -38,11 +46,11 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
def setup_clients(cls):
super(TestTempestFms, cls).setup_clients()
cls.rms_client = cls.os_primary.rms_client
cls.cms_client = cls.os_primary.cms_client
@classmethod
def resource_setup(cls):
# create flavor then save off flavor_id for use in test cases
# create flavor for use in test cases
body = cls._get_flavor_params()
cls.addClassResourceCleanup(
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(
**body)
# these variables will be used to test list filters
cls.flavor_id = cls.flavor['id']
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']
cls.tenant_id = cls._create_customer()
cls.alt_tenant_id = cls._create_customer()
# add custom extra specs
cls.custom_es = {'os_extra_specs': {'g': 'guava', 'h': 'honeydew'}}
cls.client.add_extra_specs(cls.flavor_id, cls.custom_es)
cls._wait_for_flavor_status_on_dcp(cls.flavor_id, 'Success')
cls.client.add_extra_specs(cls.flavor['id'], cls.custom_es)
cls._wait_for_flavor_status_on_dcp(cls.flavor['id'], 'Success')
# build customers for related flavor tests
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):
_, body = self.client.get_flavor(flavor_id)
return body["flavor"]
def _create_region_group(self):
_, 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']
self.addCleanup(
@ -124,7 +170,7 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
_, extra_specs = self.client.get_extra_specs(flavor_id)
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"))
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["status"], "Success")
def _create_region(self, status='functional'):
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_id': region_name,
'status': status,
}
)
return region
def _update_region(self, r_name, status=None):
if status is None:
status = {'status': 'functional'}
self.os_admin.rms_client.update_region_status(
r_name, status=status)
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.assertRaises(exceptions.NotFound,
self.client.get_flavor,
flavor_id)
@SYNC('flavor')
@decorators.idempotent_id('2a4481cd-acce-4a5d-af7c-940222a6238b')
def test_get_flavor(self):
"""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)
self.assertIn(self.flavor_id, body["flavor"]["id"])
self.assertIn(self.flavor['id'], body["flavor"]["id"])
@decorators.idempotent_id('c46a503a-951c-4d00-afaa-46076b54db16')
def test_list_flavor_with_filters(self):
@ -182,27 +222,30 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
- 'series' filter
- "tenant" filter
"""
post_body = self._get_flavor_params()
flavor = self._data_setup(post_body)
# 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,
len(self.flavor_name))
len(flavor['name']))
# define the list flavors filters to be used for this test
alias_filter = "?alias=%s" % self.alias
region_filter = "?region=%s" % self.region_id
visibility_filter = "?visibility=%s" % self.visibility
alias_filter = "?alias=%s" % flavor['alias']
region_filter = "?region=%s" % CONF.identity.region
visibility_filter = "?visibility=%s" % flavor['visibility']
contains_filter = '?contains=%s' \
% self.flavor_name[str_index1:str_index2]
startswith_filter = "?starts_with=%s" % self.flavor_name[:str_index2]
series_filter = "?series=%s" % self.series
% flavor['name'][str_index1:str_index2]
startswith_filter = "?starts_with=%s" % flavor['name'][:str_index2]
series_filter = "?series=%s" % flavor['series']
tenant_filter = "?tenant=%s" % self.tenant_id
for list_filter in [None, region_filter, visibility_filter,
alias_filter, contains_filter, startswith_filter,
series_filter, tenant_filter]:
_, body = self.client.list_flavors(list_filter)
flavor_ids = [flavor["id"] for flavor in body["flavors"]]
self.assertIn(self.flavor_id, flavor_ids)
flavor_ids = [test_flavor["id"] for test_flavor in body["flavors"]]
self.assertIn(flavor['id'], flavor_ids)
@decorators.idempotent_id('7b9d1f91-a8a4-458d-aaad-a98b5bf033b4')
def test_create_private_flavor(self):
@ -212,60 +255,69 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
def test_create_public_flavor(self):
self._assert_create_flavor(public=True)
@SYNC('flavor')
@decorators.idempotent_id('4cad10ce-67d2-4633-b347-2c16783a31b9')
def test_add_flavor_tags(self):
# test add_tags command with two sets of key:values
add_tag_body = {"tags": {"aa": "bb", "cc": "dd"}}
self._exec_tags_function(self.flavor_id, add_tag_body, 'add', None)
_, tag_body = self.client.get_tags(self.flavor_id)
self._exec_tags_function(self.flavor['id'], add_tag_body, 'add', None)
_, tag_body = self.client.get_tags(self.flavor['id'])
subset = {k: v for k, v in list(tag_body.get("tags").items())
if k in add_tag_body.get("tags")}
self.assertDictEqual(add_tag_body.get("tags"), subset)
@SYNC('flavor')
@decorators.idempotent_id('db8e5c0f-0041-45d4-9939-e079296123d8')
def test_replace_flavor_tags(self):
# test replace_tags command
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)
_, 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"),
tag_body.get("tags"))
@SYNC('flavor')
@decorators.idempotent_id('e0a0eca6-e120-45ab-a1a4-f5b95fdf97f1')
def test_delete_flavor_tag(self):
# test delete_tag command - delete a tag from tags body
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)
# 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)
self.assertIsNone(tag_present)
@SYNC('flavor')
@decorators.idempotent_id('9c511020-53ed-4139-8c53-451cb0ea8c75')
def test_delete_all_flavor_tags(self):
# 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)
# test delete_all_tags command - run get_tag again and confirm
# that the tag dict is now empty
self._exec_tags_function(self.flavor_id, None, 'delete', None)
_, tag_body = self.client.get_tags(self.flavor_id)
self._exec_tags_function(self.flavor['id'], None, 'delete', None)
_, tag_body = self.client.get_tags(self.flavor['id'])
# assert that tag_body contains nothing
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')
def test_add_delete_flavor_region(self):
# setup data to add region
region_id = CONF.identity.region
post_body = self._get_flavor_params(set_region=False)
flavor = self._data_setup(post_body)
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)
_, body = self.client.add_flavor_regions(test_flavor_id,
post_region_body)
@ -276,72 +328,81 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
# remove added region and then check to confirm flavor status
_, 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
self._wait_for_flavor_status_on_dcp(test_flavor_id, 'no regions')
# flavor region is now empty after the lone region was removed
_, body = self.client.get_flavor(test_flavor_id)
self.assertTrue(len(body["flavor"]["regions"]) == 0)
@SYNC('flavor')
@decorators.idempotent_id('71404409-5d95-472c-8dac-b49a1c0c4b37')
def test_add_flavor_extra_specs(self):
# 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")
# add custom extra specs
add_es_body = {"os_extra_specs": {"a": "apple", "b": "banana"}}
self._exec_ex_spec_function(self.flavor_id, add_es_body, 'add', None)
_, extra_specs = self.client.get_extra_specs(self.flavor_id)
self._exec_ex_spec_function(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
es_expected.update(add_es_body["os_extra_specs"])
self.assertDictEqual(es_expected, extra_specs.get("os_extra_specs"))
@SYNC('flavor')
@decorators.idempotent_id('043948fd-125b-4d96-bf40-42464066a7e1')
def test_update_flavor_extra_specs(self):
# add custom extra spec using update_extra_spec
replace_es_body = {"os_extra_specs": {"z": "zebra", "x": "xray"}}
self._exec_ex_spec_function(
self.flavor_id,
self.flavor['id'],
replace_es_body,
'update',
None)
# 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.update(self.dflt_ex_specs)
es_expected.update(self.flavor['extra-specs'])
self.assertDictEqual(es_expected,
flavor_ex_specs.get("os_extra_specs"))
@SYNC('flavor')
@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
_, 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
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)
# assert extra specs update results match expected
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"],
flavor_ex_specs.get("os_extra_specs"))
@SYNC('flavor')
@decorators.idempotent_id('e3fc7ce3-c8fe-4805-8ad3-7be2c94fe7ad')
def test_delete_all_flavor_extra_specs(self):
# run delete ALL extra specs - note that this will only
# delete custom extra specs, NOT the default extra specs
self._exec_ex_spec_function(self.flavor_id, None, 'delete', None)
_, flavor_ex_specs = self.client.get_extra_specs(self.flavor_id)
_, specs_to_restore = 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
# the default extra specs
self.assertDictEqual(self.dflt_ex_specs,
self.assertDictEqual(self.flavor['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')
def test_add_delete_flavor_tenant(self):
@ -356,10 +417,10 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
self.assertEqual(flavor["tenants"][0], self.tenant_id)
# test add_flavor_tenant by adding one more tenant
post_tenant_body = '{"tenants": ["%s"]}' % (self.alt_tenant_id)
post_tenant_body = json.loads(post_tenant_body)
alt_tenant_body = '{"tenants": ["%s"]}' % (self.alt_tenant_id)
alt_tenant_body = json.loads(alt_tenant_body)
_, 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')
# 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):
# setup data for test case
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(
**post_body)
test_flavor_id = flavor['id']
# 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,
test_flavor_id)
flavor['id'])
@decorators.idempotent_id('2a1240d8-ae30-4c37-b99f-af961a5e16cb')
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')
def test_create_flavor_with_two_regions(self):
region_alt = CONF.ranger.alt_region
if not region_alt:
if not self.region_alt:
raise exceptions.InvalidConfiguration(
'Provide region_alt in ranger block in configuration file')
post_body = self._get_flavor_params()
post_body['regions'].append(
{'name': region_alt}
{'name': self.region_alt}
)
flavor = self._data_setup(post_body)
test_flavor_id = flavor['id']
flavor_details = self._get_flavor_details(test_flavor_id)
self.assertEqual(flavor_details['status'], 'Success')
self.assertEqual(flavor['regions'][0]['name'], CONF.identity.region)
self.assertEqual(flavor['regions'][1]['name'], region_alt)
self.assertEqual(len(flavor['regions']), 2)
@decorators.idempotent_id('06c81b29-85b6-4edf-ab89-3877c49e23bc')
def test_create_flavor_with_single_and_group_region(self):
region_alt = CONF.ranger.alt_region
if not region_alt:
def test_create_flavor_with_group_region(self):
if not self.region_alt:
raise exceptions.InvalidConfiguration(
'Provide region_alt in ranger block in configuration file')
group_id = self._create_region_group()
@ -487,18 +543,14 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
post_body['regions'] = [
{
'name': group_id,
'type': 'group',
},
{
'name': region_alt,
'type': 'single',
'type': 'group'
}
]
flavor = self._data_setup(post_body)
flavor_details = self._get_flavor_details(flavor['id'])
self.assertEqual(flavor_details['status'], 'Success')
self.assertEqual(flavor['regions'][0]['name'], CONF.identity.region)
self.assertEqual(flavor['regions'][1]['name'], region_alt)
self.assertEqual(flavor['regions'][0]['name'], self.region)
self.assertEqual(flavor['regions'][1]['name'], self.region_alt)
@decorators.idempotent_id('997ca03c-4176-4632-a0c9-7e943b03306d')
def test_create_flavor_with_uuid(self):
@ -510,25 +562,22 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
@decorators.idempotent_id('37f1909f-3ba2-403c-ba0c-0a11b869d6a1')
def test_flavor_while_region_down(self):
# create region with status down
region = self._create_region(status='down')
# update region to status down
self._update_region(self.region, status={'status': 'down'})
# create flavor within that newly created region
post_body = self._get_flavor_params()
post_body['regions'][0]['name'] = region['name']
post_body = self._get_flavor_params(set_region=False)
post_body['regions'] = [{'name': self.region}]
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')
def test_flavor_while_region_building(self):
# create region with status building
region = self._create_region(status='building')
post_body = self._get_flavor_params()
post_body['regions'][0]['name'] = region['name']
self.addCleanup(
self._delete_flavor,
post_body['id'])
# update region to status building
self._update_region(self.region, status={'status': 'building'})
post_body = self._get_flavor_params(set_region=False)
post_body['regions'] = [{'name': self.region}]
body = self._data_setup(post_body)
self.assertIn('id', body)
@ -536,19 +585,21 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
flavor = self._get_flavor_details(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')
def test_flavor_while_region_maintenance(self):
# create region with status maintenance
region = self._create_region(status='maintenance')
# update region to status maintenance
self._update_region(self.region, status={'status': 'maintenance'})
post_body = self._get_flavor_params()
post_body['regions'][0]['name'] = region['name']
post_body = self._get_flavor_params(set_region=False)
post_body['regions'] = [{'name': self.region}]
body = self._data_setup(post_body)
self.assertIn('id', body)
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'], '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 tempest import config
CONF = config.CONF
class TestTempestFmsNegative(base.BaseOrmTest):
@ -30,16 +26,12 @@ class TestTempestFmsNegative(base.BaseOrmTest):
@classmethod
def setup_clients(cls):
super(TestTempestFmsNegative, cls).setup_clients()
cls.client = cls.fmsclient
cls.client = cls.os_primary.fms_client
@classmethod
def resource_setup(cls):
cls.set_role_to_admin()
super(TestTempestFmsNegative, cls).resource_setup()
cls.env_name = cls.env_name
cls.tenant_id = cls.tenant_id
@classmethod
def resource_cleanup(cls):
cls.delete_role_to_admin()
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,
'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

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 tempest import config
CONF = config.CONF
class TestTempestImsNegative(base.BaseOrmTest):
@ -30,19 +26,12 @@ class TestTempestImsNegative(base.BaseOrmTest):
@classmethod
def setup_clients(cls):
super(TestTempestImsNegative, cls).setup_clients()
cls.client = cls.imsclient
cls.servers_client = cls.servers_client
cls.client = cls.os_primary.ims_client
@classmethod
def resource_setup(cls):
cls.set_role_to_admin()
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
def resource_cleanup(cls):
cls.delete_role_to_admin()
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.tests.api import base
from tempest import config
from tempest.lib import decorators
from tempest.lib import exceptions
from tempest.lib.common.utils import data_utils
CONF = config.CONF
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 tempest import config
CONF = config.CONF
class TestTempestRegGroupNegative(base.BaseOrmTest):
@ -30,14 +26,12 @@ class TestTempestRegGroupNegative(base.BaseOrmTest):
@classmethod
def setup_clients(cls):
super(TestTempestRegGroupNegative, cls).setup_clients()
cls.client = cls.rmsclient
cls.client = cls.os_primary.rms_client
@classmethod
def resource_setup(cls):
cls.set_role_to_admin()
super(TestTempestRegGroupNegative, cls).resource_setup()
@classmethod
def resource_cleanup(cls):
cls.delete_role_to_admin()
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.tests.api import rms_base
from tempest import config
from tempest.lib import decorators
from tempest.lib import exceptions
from tempest.lib.common.utils import data_utils
CONF = config.CONF
class TestTempestRegion(rms_base.RmsBaseOrmTest):
@ -108,13 +102,13 @@ class TestTempestRegion(rms_base.RmsBaseOrmTest):
@decorators.idempotent_id('358f3cbc-4ae5-4b43-be36-6df55eae8fd9')
def test_get_region(self):
_, body = self.client.get_region(self.region_1['id'])
self.assert_expected(self.region_1, body, [])
_, body = self.client.get_region(self.region_2['id'])
self.assert_expected(self.region_2, body, [])
@decorators.idempotent_id('cefb952f-7777-4878-87d2-d78ac345f0d2')
def test_get_region_metadata(self):
_, body = self.client.get_region_metadata(self.region_1['id'])
self.assert_expected(self.region_1['metadata'], body['metadata'], [])
_, body = self.client.get_region_metadata(self.region_2['id'])
self.assert_expected({'metadata': {'key': ['value']}}, body, [])
@decorators.idempotent_id('b2c3baf5-22af-4bf9-bcad-b6a1a74e82d9')
def test_update_region(self):
@ -130,6 +124,8 @@ class TestTempestRegion(rms_base.RmsBaseOrmTest):
[self.region_1['status']])
_, body = self.client.update_region_status(self.region_1['id'], status)
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')
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 tempest import config
CONF = config.CONF
class TestTempestRegionsNegative(base.BaseOrmTest):
@ -30,14 +26,12 @@ class TestTempestRegionsNegative(base.BaseOrmTest):
@classmethod
def setup_clients(cls):
super(TestTempestRegionsNegative, cls).setup_clients()
cls.client = cls.rmsclient
cls.client = cls.os_primary.rms_client
@classmethod
def resource_setup(cls):
cls.set_role_to_admin()
super(TestTempestRegionsNegative, cls).resource_setup()
@classmethod
def resource_cleanup(cls):
cls.delete_role_to_admin()
super(TestTempestRegionsNegative, cls).resource_cleanup()