openstack/vitrage
Code Issues Proposed changes

Tempest refactoring

Browse Source 
move code around so useful methods are in a common place.
create a clients singleton holding all required clients for testing.

Change-Id: I65d0a8b494ef760b9d14f132f5611cfefde03dc7
This commit is contained in:
Idan Hefetz 2017-11-05 10:40:18 +00:00
parent 6bd6c2e053
commit 6bdab3e626
27 changed files with 511 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
vitrage_tempest_tests/tests/api/alarms/base.py
View File

@ -12,71 +12,23 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import random from vitrage_tempest_tests.tests.base import BaseVitrageTempest
import time from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
from vitrage import os_clients
from vitrage_tempest_tests.tests.api.base import BaseApiTest
TEMPLATES_RESOURCES_PATH = 'resources/templates/' TEMPLATES_RESOURCES_PATH = 'resources/templates/'
TEMPLATES_SOURCES_PATH = '/etc/vitrage/templates/' TEMPLATES_SOURCES_PATH = '/etc/vitrage/templates/'
class BaseAlarmsTest(BaseApiTest): class BaseAlarmsTest(BaseVitrageTempest):
"""Topology test class for Vitrage API tests.""" """Topology test class for Vitrage API tests."""
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
super(BaseAlarmsTest, cls).setUpClass() super(BaseAlarmsTest, cls).setUpClass()
cls.ceilometer_client = os_clients.ceilometer_client(cls.conf)
def _create_ceilometer_alarm(self, resource_id=None,
name=None, unic=True):
if not name:
name = '%s-%s' % ('test_', random.randrange(0, 100000, 1))
elif unic:
name = '%s-%s' % (name, random.randrange(0, 100000, 1))
aodh_request = self._aodh_request(resource_id=resource_id, name=name)
self.ceilometer_client.alarms.create(**aodh_request)
self._wait_for_status(20,
self._check_num_alarms,
num_alarms=1,
state='alarm')
time.sleep(25)
def _delete_ceilometer_alarms(self):
alarms = self.ceilometer_client.alarms.list()
for alarm in alarms:
self.ceilometer_client.alarms.delete(alarm.alarm_id)
self._wait_for_status(20,
self._check_num_alarms,
num_alarms=0)
time.sleep(120)
@staticmethod
def _aodh_request(resource_id=None, name=None):
query = []
if resource_id:
query = [
dict(
field=u'traits.resource_id',
type='',
op=u'eq',
value=resource_id)
]
return dict(
name=name,
description=u'test alarm',
event_rule=dict(query=query),
severity='low',
state='alarm',
type=u'event')
def _check_num_alarms(self, num_alarms=0, state=''): def _check_num_alarms(self, num_alarms=0, state=''):
if len(self.ceilometer_client.alarms.list()) != num_alarms: if len(TempestClients.ceilometer().alarms.list()) != num_alarms:
return False return False
return all(alarm.state.upper() == state.upper() return all(alarm.state.upper() == state.upper()
for alarm in self.ceilometer_client.alarms.list()) for alarm in TempestClients.ceilometer().alarms.list())

18
vitrage_tempest_tests/tests/api/alarms/test_alarms.py
View File

@ -19,7 +19,10 @@ from oslo_log import log as logging
from vitrage.common.constants import VertexProperties as VProps from vitrage.common.constants import VertexProperties as VProps
from vitrage.datasources.aodh import AODH_DATASOURCE from vitrage.datasources.aodh import AODH_DATASOURCE
from vitrage_tempest_tests.tests.api.alarms.base import BaseAlarmsTest from vitrage_tempest_tests.tests.api.alarms.base import BaseAlarmsTest
import vitrage_tempest_tests.tests.utils as utils from vitrage_tempest_tests.tests.common import ceilometer_utils
from vitrage_tempest_tests.tests.common import nova_utils
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
from vitrage_tempest_tests.tests import utils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -35,13 +38,14 @@ class TestAlarms(BaseAlarmsTest):
def test_compare_cli_vs_api_alarms(self): def test_compare_cli_vs_api_alarms(self):
"""Wrapper that returns a test graph.""" """Wrapper that returns a test graph."""
try: try:
instances = self._create_instances(num_instances=1) instances = nova_utils.create_instances(num_instances=1)
self.assertNotEqual(len(instances), 0, self.assertNotEqual(len(instances), 0,
'The instances list is empty') 'The instances list is empty')
self._create_ceilometer_alarm(resource_id=instances[0].id, ceilometer_utils.create_ceilometer_alarm(
name='tempest_aodh_test') resource_id=instances[0].id,
name='tempest_aodh_test')
api_alarms = self.vitrage_client.alarm.list(vitrage_id=None) api_alarms = TempestClients.vitrage().alarm.list(vitrage_id=None)
cli_alarms = utils.run_vitrage_command( cli_alarms = utils.run_vitrage_command(
'vitrage alarm list', self.conf) 'vitrage alarm list', self.conf)
self._compare_alarms_lists( self._compare_alarms_lists(
@ -51,8 +55,8 @@ class TestAlarms(BaseAlarmsTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_ceilometer_alarms() ceilometer_utils.delete_all_ceilometer_alarms()
self._delete_instances() nova_utils.delete_all_instances()
def _compare_alarms_lists(self, api_alarms, cli_alarms, def _compare_alarms_lists(self, api_alarms, cli_alarms,
resource_type, resource_id): resource_type, resource_id):

13
vitrage_tempest_tests/tests/api/event/base.py
View File

@ -14,27 +14,20 @@
from datetime import datetime from datetime import datetime
from oslo_log import log as logging from oslo_log import log as logging
from vitrage_tempest_tests.tests.base import BaseVitrageTempest
from vitrage import keystone_client
from vitrage import service
from vitrage_tempest_tests.tests.api.base import BaseApiTest
from vitrageclient import client as v_client
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
DOWN = 'down' DOWN = 'down'
UP = 'up' UP = 'up'
class BaseTestEvents(BaseApiTest): class BaseTestEvents(BaseVitrageTempest):
"""Test class for Vitrage event API""" """Test class for Vitrage event API"""
# noinspection PyPep8Naming # noinspection PyPep8Naming
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
cls.conf = service.prepare_service([]) super(BaseTestEvents, cls).setUpClass()
cls.vitrage_client = \
v_client.Client('1', session=keystone_client.get_session(cls.conf))
def _check_alarms(self): def _check_alarms(self):
api_alarms = self.vitrage_client.alarm.list(vitrage_id='all', api_alarms = self.vitrage_client.alarm.list(vitrage_id='all',

17
vitrage_tempest_tests/tests/api/rca/base.py
View File

@ -29,7 +29,10 @@ from vitrage.entity_graph.mappings.operational_resource_state \
from vitrage.evaluator.actions.evaluator_event_transformer \ from vitrage.evaluator.actions.evaluator_event_transformer \
import VITRAGE_DATASOURCE import VITRAGE_DATASOURCE
from vitrage_tempest_tests.tests.api.alarms.base import BaseAlarmsTest from vitrage_tempest_tests.tests.api.alarms.base import BaseAlarmsTest
import vitrage_tempest_tests.tests.utils as utils from vitrage_tempest_tests.tests.common import ceilometer_utils
from vitrage_tempest_tests.tests.common import nova_utils
from vitrage_tempest_tests.tests.common import vitrage_utils
from vitrage_tempest_tests.tests import utils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
RCA_ALARM_NAME = 'rca_test_host_alarm' RCA_ALARM_NAME = 'rca_test_host_alarm'
@ -43,12 +46,13 @@ class BaseRcaTest(BaseAlarmsTest):
super(BaseRcaTest, cls).setUpClass() super(BaseRcaTest, cls).setUpClass()
def _clean_all(self): def _clean_all(self):
self._delete_instances() nova_utils.delete_all_instances()
self._delete_ceilometer_alarms() ceilometer_utils.delete_all_ceilometer_alarms()
def _create_alarm(self, resource_id, alarm_name, unic=False): def _create_alarm(self, resource_id, alarm_name, unic=False):
self._create_ceilometer_alarm(resource_id=resource_id, ceilometer_utils.create_ceilometer_alarm(resource_id=resource_id,
name=alarm_name, unic=unic) name=alarm_name,
unic=unic)
list_alarms = self.vitrage_client.alarm.list(vitrage_id=None) list_alarms = self.vitrage_client.alarm.list(vitrage_id=None)
expected_alarm = self._filter_list_by_pairs_parameters( expected_alarm = self._filter_list_by_pairs_parameters(
@ -186,7 +190,8 @@ class BaseRcaTest(BaseAlarmsTest):
self.assertEqual(3, len(alarms)) self.assertEqual(3, len(alarms))
def _get_hostname(self): def _get_hostname(self):
return self._get_value(item=self._get_host(), key=VProps.ID) host = vitrage_utils.get_first_host()
return self._get_value(item=host, key=VProps.ID)
@staticmethod @staticmethod
def _clean_timestamps(alist): def _clean_timestamps(alist):

19
vitrage_tempest_tests/tests/api/rca/test_rca.py
View File

@ -17,7 +17,9 @@ from oslo_log import log as logging
from vitrage.common.constants import VertexProperties as VProps from vitrage.common.constants import VertexProperties as VProps
from vitrage_tempest_tests.tests.api.rca.base import BaseRcaTest from vitrage_tempest_tests.tests.api.rca.base import BaseRcaTest
from vitrage_tempest_tests.tests.api.rca.base import RCA_ALARM_NAME from vitrage_tempest_tests.tests.api.rca.base import RCA_ALARM_NAME
import vitrage_tempest_tests.tests.utils as utils from vitrage_tempest_tests.tests.common import nova_utils
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
from vitrage_tempest_tests.tests import utils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -37,7 +39,7 @@ class TestRca(BaseRcaTest):
aodh event alarms, and compare them with cli rca aodh event alarms, and compare them with cli rca
""" """
try: try:
instances = self._create_instances(num_instances=1) instances = nova_utils.create_instances(num_instances=1)
self.assertNotEqual(len(instances), 0, 'Failed to create instance') self.assertNotEqual(len(instances), 0, 'Failed to create instance')
instance_alarm = self._create_alarm( instance_alarm = self._create_alarm(
@ -68,7 +70,7 @@ class TestRca(BaseRcaTest):
target alarms - 2 instance alarms (caused 2 created instance) target alarms - 2 instance alarms (caused 2 created instance)
""" """
try: try:
self._create_instances(num_instances=2) nova_utils.create_instances(num_instances=2)
host_alarm = self._create_alarm( host_alarm = self._create_alarm(
resource_id=self._get_hostname(), resource_id=self._get_hostname(),
alarm_name=RCA_ALARM_NAME, alarm_name=RCA_ALARM_NAME,
@ -95,7 +97,7 @@ class TestRca(BaseRcaTest):
resource_id with created instances id resource_id with created instances id
""" """
try: try:
instances = self._create_instances(num_instances=2) instances = nova_utils.create_instances(num_instances=2)
self._create_alarm( self._create_alarm(
resource_id=self._get_hostname(), resource_id=self._get_hostname(),
alarm_name=RCA_ALARM_NAME) alarm_name=RCA_ALARM_NAME)
@ -119,7 +121,7 @@ class TestRca(BaseRcaTest):
target state - SUBOPTIMAL (caused 2 created instance) target state - SUBOPTIMAL (caused 2 created instance)
""" """
try: try:
instances = self._create_instances(num_instances=2) instances = nova_utils.create_instances(num_instances=2)
self._create_alarm( self._create_alarm(
resource_id=self._get_hostname(), resource_id=self._get_hostname(),
alarm_name=RCA_ALARM_NAME) alarm_name=RCA_ALARM_NAME)
@ -143,12 +145,13 @@ class TestRca(BaseRcaTest):
IMPORTANT: enable notifiers=aodh in vitrage.conf file IMPORTANT: enable notifiers=aodh in vitrage.conf file
""" """
try: try:
self._create_instances(num_instances=2) nova_utils.create_instances(num_instances=2)
self._create_alarm( self._create_alarm(
resource_id=self._get_hostname(), resource_id=self._get_hostname(),
alarm_name=RCA_ALARM_NAME) alarm_name=RCA_ALARM_NAME)
vitrage_alarms = self.vitrage_client.alarm.list(vitrage_id=None) vitrage_alarms = TempestClients.vitrage().alarm.list(
ceilometer_alarms = self.ceilometer_client.alarms.list() vitrage_id=None)
ceilometer_alarms = TempestClients.ceilometer().alarms.list()
self._validate_notifier(alarms=ceilometer_alarms, self._validate_notifier(alarms=ceilometer_alarms,
vitrage_alarms=vitrage_alarms) vitrage_alarms=vitrage_alarms)

30
vitrage_tempest_tests/tests/api/resources/test_resources.py
View File

@ -19,14 +19,14 @@ from oslo_log import log as logging
from vitrage.common.constants import VertexProperties as VProps from vitrage.common.constants import VertexProperties as VProps
from vitrage.datasources import CINDER_VOLUME_DATASOURCE from vitrage.datasources import CINDER_VOLUME_DATASOURCE
from vitrage.datasources import NOVA_INSTANCE_DATASOURCE from vitrage.datasources import NOVA_INSTANCE_DATASOURCE
from vitrage_tempest_tests.tests.api.base import BaseApiTest from vitrage_tempest_tests.tests.base import BaseVitrageTempest
import vitrage_tempest_tests.tests.utils as utils from vitrage_tempest_tests.tests.common import nova_utils
from vitrage_tempest_tests.tests import utils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
class TestResource(BaseApiTest): class TestResource(BaseVitrageTempest):
"""Test class for Vitrage resource API tests.""" """Test class for Vitrage resource API tests."""
properties = (VProps.VITRAGE_ID, properties = (VProps.VITRAGE_ID,
@ -43,7 +43,7 @@ class TestResource(BaseApiTest):
def test_compare_cli_vs_api_resource_list(self): def test_compare_cli_vs_api_resource_list(self):
"""resource list """ """resource list """
try: try:
instances = self._create_instances(num_instances=1) instances = nova_utils.create_instances(num_instances=1)
self.assertNotEqual(len(instances), 0, self.assertNotEqual(len(instances), 0,
'The instances list is empty') 'The instances list is empty')
api_resources = self.vitrage_client.resource.list() api_resources = self.vitrage_client.resource.list()
@ -55,7 +55,7 @@ class TestResource(BaseApiTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_instances() nova_utils.delete_all_instances()
@utils.tempest_logger @utils.tempest_logger
def test_default_resource_list(self): def test_default_resource_list(self):
@ -64,7 +64,7 @@ class TestResource(BaseApiTest):
get the resources: cluster, zone, host and one instance get the resources: cluster, zone, host and one instance
""" """
try: try:
instances = self._create_instances(num_instances=1) instances = nova_utils.create_instances(num_instances=1)
self.assertNotEqual(len(instances), 0, self.assertNotEqual(len(instances), 0,
'The instances list is empty') 'The instances list is empty')
resources = self.vitrage_client.resource.list() resources = self.vitrage_client.resource.list()
@ -73,7 +73,7 @@ class TestResource(BaseApiTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_instances() nova_utils.delete_all_instances()
@utils.tempest_logger @utils.tempest_logger
def test_resource_list_with_all_tenants(self): def test_resource_list_with_all_tenants(self):
@ -83,7 +83,7 @@ class TestResource(BaseApiTest):
cluster, zone, host and one instance(no other tenants) cluster, zone, host and one instance(no other tenants)
""" """
try: try:
instances = self._create_instances(num_instances=1) instances = nova_utils.create_instances(num_instances=1)
self.assertNotEqual(len(instances), 0, self.assertNotEqual(len(instances), 0,
'The instances list is empty') 'The instances list is empty')
resources = self.vitrage_client.resource.list(all_tenants=True) resources = self.vitrage_client.resource.list(all_tenants=True)
@ -92,7 +92,7 @@ class TestResource(BaseApiTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_instances() nova_utils.delete_all_instances()
@utils.tempest_logger @utils.tempest_logger
def test_resource_list_with_existing_type(self): def test_resource_list_with_existing_type(self):
@ -101,7 +101,7 @@ class TestResource(BaseApiTest):
get the resource: one instance get the resource: one instance
""" """
try: try:
instances = self._create_instances(num_instances=1) instances = nova_utils.create_instances(num_instances=1)
self.assertNotEqual(len(instances), 0, self.assertNotEqual(len(instances), 0,
'The instances list is empty') 'The instances list is empty')
resources = self.vitrage_client.resource.list( resources = self.vitrage_client.resource.list(
@ -112,13 +112,13 @@ class TestResource(BaseApiTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_instances() nova_utils.delete_all_instances()
@utils.tempest_logger @utils.tempest_logger
def test_resource_list_with_no_existing_type(self): def test_resource_list_with_no_existing_type(self):
"""resource list with no existing type""" """resource list with no existing type"""
try: try:
instances = self._create_instances(num_instances=1) instances = nova_utils.create_instances(num_instances=1)
self.assertNotEqual(len(instances), 0, self.assertNotEqual(len(instances), 0,
'The instances list is empty') 'The instances list is empty')
resources = self.vitrage_client.resource.list( resources = self.vitrage_client.resource.list(
@ -129,7 +129,7 @@ class TestResource(BaseApiTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_instances() nova_utils.delete_all_instances()
def test_compare_resource_show(self): def test_compare_resource_show(self):
"""resource_show test""" """resource_show test"""
@ -155,7 +155,7 @@ class TestResource(BaseApiTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_instances() nova_utils.delete_all_instances()
def _compare_resources(self, api_resources, cli_resources): def _compare_resources(self, api_resources, cli_resources):
self.assertNotEqual(len(api_resources), 0, self.assertNotEqual(len(api_resources), 0,

8
vitrage_tempest_tests/tests/api/templates/base.py
View File

@ -15,14 +15,13 @@ import json
from oslo_log import log as logging from oslo_log import log as logging
from vitrage import os_clients from vitrage_tempest_tests.tests.base import BaseVitrageTempest
from vitrage_tempest_tests.tests.api.base import BaseApiTest from vitrage_tempest_tests.tests import utils
import vitrage_tempest_tests.tests.utils as utils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
class BaseTemplateTest(BaseApiTest): class BaseTemplateTest(BaseVitrageTempest):
"""Template test class for Vitrage API tests.""" """Template test class for Vitrage API tests."""
DEFAULT_PATH = '/etc/vitrage/templates/' DEFAULT_PATH = '/etc/vitrage/templates/'
@ -40,7 +39,6 @@ class BaseTemplateTest(BaseApiTest):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
super(BaseTemplateTest, cls).setUpClass() super(BaseTemplateTest, cls).setUpClass()
cls.ceilometer_client = os_clients.ceilometer_client(cls.conf)
def _compare_template_lists(self, api_templates, cli_templates): def _compare_template_lists(self, api_templates, cli_templates):
self.assertNotEqual(len(api_templates), 0, self.assertNotEqual(len(api_templates), 0,

18
vitrage_tempest_tests/tests/api/topology/base.py
View File

@ -16,10 +16,12 @@ import json
import time import time
from vitrage.common.constants import VertexProperties as VProps from vitrage.common.constants import VertexProperties as VProps
from vitrage_tempest_tests.tests.api.base import BaseApiTest from vitrage_tempest_tests.tests.base import BaseVitrageTempest
from vitrage_tempest_tests.tests.common import cinder_utils
from vitrage_tempest_tests.tests.common import nova_utils
class BaseTopologyTest(BaseApiTest): class BaseTopologyTest(BaseVitrageTempest):
"""Topology test class for Vitrage API tests.""" """Topology test class for Vitrage API tests."""
@classmethod @classmethod
@ -43,21 +45,21 @@ class BaseTopologyTest(BaseApiTest):
def _create_entities(self, num_instances=0, num_volumes=0, end_sleep=3): def _create_entities(self, num_instances=0, num_volumes=0, end_sleep=3):
if num_instances > 0: if num_instances > 0:
resources = self._create_instances(num_instances) resources = nova_utils.create_instances(num_instances)
self.assertNotEqual(len(resources), 0, 'The instances list is empty') self.assertNotEqual(len(resources), 0, 'The instances list is empty')
if num_volumes > 0: if num_volumes > 0:
self._create_volume_and_attach('volume-1', 1, cinder_utils.create_volume_and_attach('volume-1', 1,
resources[0].id, resources[0].id,
'/tmp/vda') '/tmp/vda')
# waiting until all the entities creation were processed by the # waiting until all the entities creation were processed by the
# entity graph processor # entity graph processor
time.sleep(end_sleep) time.sleep(end_sleep)
def _delete_entities(self): def _delete_entities(self):
self._delete_volumes() cinder_utils.delete_all_volumes()
self._delete_instances() nova_utils.delete_all_instances()
# waiting until all the entities deletion were processed by the # waiting until all the entities deletion were processed by the
# entity graph processor # entity graph processor

155
vitrage_tempest_tests/tests/api/base.py → vitrage_tempest_tests/tests/base.py
View File

@ -12,12 +12,10 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import time
import traceback import traceback
from oslo_log import log as logging from oslo_log import log as logging
from oslotest import base from oslotest import base
from six.moves import filter
from vitrage.common.constants import EdgeProperties from vitrage.common.constants import EdgeProperties
from vitrage.common.constants import EntityCategory from vitrage.common.constants import EntityCategory
@ -35,17 +33,15 @@ from vitrage.datasources.static_physical import SWITCH
from vitrage.graph.driver.networkx_graph import NXGraph from vitrage.graph.driver.networkx_graph import NXGraph
from vitrage.graph import Edge from vitrage.graph import Edge
from vitrage.graph import Vertex from vitrage.graph import Vertex
from vitrage import keystone_client
from vitrage import os_clients
from vitrage import service from vitrage import service
import vitrage_tempest_tests.tests.utils as utils from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
from vitrageclient import client as v_client from vitrage_tempest_tests.tests import utils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
class BaseApiTest(base.BaseTestCase): class BaseVitrageTempest(base.BaseTestCase):
"""Base test class for Vitrage API tests.""" """Base test class for All Vitrage tests."""
NUM_VERTICES_PER_TYPE = 'num_vertices' NUM_VERTICES_PER_TYPE = 'num_vertices'
NUM_EDGES_PER_TYPE = 'num_edges_per_type' NUM_EDGES_PER_TYPE = 'num_edges_per_type'
@ -53,43 +49,18 @@ class BaseApiTest(base.BaseTestCase):
# noinspection PyPep8Naming # noinspection PyPep8Naming
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
super(BaseApiTest, cls).setUpClass() super(BaseVitrageTempest, cls).setUpClass()
cls.conf = service.prepare_service([]) cls.conf = service.prepare_service([])
TempestClients.class_init(cls.conf)
cls.vitrage_client = \ cls.vitrage_client = TempestClients.vitrage()
v_client.Client('1', session=keystone_client.get_session(cls.conf))
cls.nova_client = cls._create_client(os_clients.nova_client, cls.conf)
cls.cinder_client = cls._create_client(os_clients.cinder_client,
cls.conf)
cls.glance_client = cls._create_client(os_clients.glance_client,
cls.conf)
cls.neutron_client = cls._create_client(os_clients.neutron_client,
cls.conf)
cls.heat_client = cls._create_client(os_clients.heat_client, cls.conf)
cls.num_default_networks = \ cls.num_default_networks = \
len(cls.neutron_client.list_networks()['networks']) len(TempestClients.neutron().list_networks()['networks'])
cls.num_default_ports = \ cls.num_default_ports = \
len(cls.neutron_client.list_ports()['ports']) len(TempestClients.neutron().list_ports()['ports'])
cls.num_default_entities = 3 cls.num_default_entities = 3
cls.num_default_edges = 2 cls.num_default_edges = 2
@staticmethod
def _create_client(client_func, conf):
count = 0
while count < 40:
LOG.info("wait_for_client - " + client_func.__name__)
client = client_func(conf)
if client:
return client
count += 1
time.sleep(5)
LOG.info("wait_for_client - False")
return None
@staticmethod @staticmethod
def _filter_list_by_pairs_parameters(origin_list, def _filter_list_by_pairs_parameters(origin_list,
keys, values): keys, values):
@ -105,97 +76,20 @@ class BaseApiTest(base.BaseTestCase):
filtered_list.append(item) filtered_list.append(item)
return filtered_list return filtered_list
def _create_volume_and_attach(self, name, size, instance_id, mount_point):
volume = self.cinder_client.volumes.create(name=name,
size=size)
time.sleep(2)
self.cinder_client.volumes.attach(volume=volume,
instance_uuid=instance_id,
mountpoint=mount_point)
self._wait_for_status(30,
self._check_num_volumes,
num_volumes=1,
state='in-use')
time.sleep(2)
return volume
def _get_host(self):
topology = self.vitrage_client.topology.get(all_tenants=True)
host = filter(
lambda item: item[VProps.VITRAGE_TYPE] == NOVA_HOST_DATASOURCE,
topology['nodes'])
return next(host)
def _create_instances(self, num_instances, set_public_network=False):
kwargs = {}
flavors_list = self.nova_client.flavors.list()
images_list = self.glance_client.images.list()
if set_public_network:
public_net = self._get_public_network()
if public_net:
kwargs.update({"networks": [{'uuid': public_net['id']}]})
img = images_list.next()
resources = [self.nova_client.servers.create(
name='%s-%s' % ('vm', index),
flavor=flavors_list[0],
image=img,
**kwargs) for index in range(num_instances)]
self._wait_for_status(30,
self._check_num_instances,
num_instances=num_instances,
state='active')
time.sleep(2)
return resources
def _delete_instances(self):
instances = self.nova_client.servers.list()
for instance in instances:
try:
self.nova_client.servers.delete(instance)
except Exception:
pass
self._wait_for_status(30,
self._check_num_instances,
num_instances=0)
time.sleep(2)
def _delete_volumes(self):
volumes = self.cinder_client.volumes.list()
for volume in volumes:
try:
self.cinder_client.volumes.detach(volume)
self.cinder_client.volumes.force_delete(volume)
except Exception:
self.cinder_client.volumes.force_delete(volume)
self._wait_for_status(30,
self._check_num_volumes,
num_volumes=0)
time.sleep(2)
def _check_num_instances(self, num_instances=0, state=''): def _check_num_instances(self, num_instances=0, state=''):
if len(self.nova_client.servers.list()) != num_instances: if len(TempestClients.nova().servers.list()) != num_instances:
return False return False
return all(instance.__dict__['status'].upper() == state.upper() return all(instance.__dict__['status'].upper() == state.upper()
for instance in self.nova_client.servers.list()) for instance in TempestClients.nova().servers.list())
def _check_num_volumes(self, num_volumes=0, state=''): def _check_num_volumes(self, num_volumes=0, state=''):
if len(self.cinder_client.volumes.list()) != num_volumes: if len(TempestClients.cinder().volumes.list()) != num_volumes:
return False return False
return all(volume.__dict__['status'].upper() == state.upper() and return all(volume.__dict__['status'].upper() == state.upper() and
len(volume.__dict__['attachments']) == 1 len(volume.__dict__['attachments']) == 1
for volume in self.cinder_client.volumes.list()) for volume in TempestClients.cinder().volumes.list())
def _create_graph_from_graph_dictionary(self, api_graph): def _create_graph_from_graph_dictionary(self, api_graph):
self.assertIsNotNone(api_graph) self.assertIsNotNone(api_graph)
@ -236,17 +130,6 @@ class BaseApiTest(base.BaseTestCase):
return graph return graph
@staticmethod
def _wait_for_status(max_waiting, func, **kwargs):
count = 0
while count < max_waiting:
if func(**kwargs):
return True
count += 1
time.sleep(2)
LOG.info("wait_for_status - False")
return False
def _entities_validation_data(self, **kwargs): def _entities_validation_data(self, **kwargs):
validation_data = [] validation_data = []
@ -373,18 +256,8 @@ class BaseApiTest(base.BaseTestCase):
def _get_value(item, key): def _get_value(item, key):
return utils.uni2str(item[key]) return utils.uni2str(item[key])
def _get_public_network(self):
networks = self.neutron_client.list_networks()
public_nets = filter(
lambda item: self._get_value(item, VProps.NAME) == 'public',
networks['networks'])
try:
return next(public_nets)
except StopIteration:
return None
def _print_entity_graph(self): def _print_entity_graph(self):
api_graph = self.vitrage_client.topology.get(all_tenants=True) api_graph = TempestClients.vitrage().topology.get(all_tenants=True)
graph = self._create_graph_from_graph_dictionary(api_graph) graph = self._create_graph_from_graph_dictionary(api_graph)
LOG.info('Entity Graph: \n%s', graph.json_output_graph()) LOG.info('Entity Graph: \n%s', graph.json_output_graph())

2
vitrage_tempest_tests/tests/scenario/__init__.py → vitrage_tempest_tests/tests/common/__init__.py
View File

@ -1,4 +1,4 @@
# Copyright 2016 - Nokia # Copyright 2017 - Nokia
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain # not use this file except in compliance with the License. You may obtain

54
vitrage_tempest_tests/tests/common/ceilometer_utils.py Normal file
View File

@ -0,0 +1,54 @@
# Copyright 2017 - Nokia
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import random
import time
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
def create_ceilometer_alarm(resource_id=None, name=None, unic=True):
if not name:
name = '%s-%s' % ('test_', random.randrange(0, 100000, 1))
elif unic:
name = '%s-%s' % (name, random.randrange(0, 100000, 1))
aodh_request = _aodh_request(resource_id=resource_id, name=name)
TempestClients.ceilometer().alarms.create(**aodh_request)
time.sleep(45)
def delete_all_ceilometer_alarms():
alarms = TempestClients.ceilometer().alarms.list()
for alarm in alarms:
TempestClients.ceilometer().alarms.delete(alarm.alarm_id)
time.sleep(120)
def _aodh_request(resource_id=None, name=None):
query = []
if resource_id:
query = [
dict(
field=u'traits.resource_id',
type='',
op=u'eq',
value=resource_id)
]
return dict(
name=name,
description=u'test alarm',
event_rule=dict(query=query),
severity='low',
state='alarm',
type=u'event')

49
vitrage_tempest_tests/tests/common/cinder_utils.py Normal file
View File

@ -0,0 +1,49 @@
# Copyright 2017 - Nokia
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import time
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
from vitrage_tempest_tests.tests.utils import wait_for_status
def create_volume_and_attach(name, size, instance_id, mount_point):
volume = TempestClients.cinder().volumes.create(name=name,
size=size)
time.sleep(2)
TempestClients.cinder().volumes.attach(volume=volume,
instance_uuid=instance_id,
mountpoint=mount_point)
wait_for_status(30, _check_num_volumes, num_volumes=1, state='in-use')
time.sleep(2)
return volume
def delete_all_volumes():
volumes = TempestClients.cinder().volumes.list()
for volume in volumes:
try:
TempestClients.cinder().volumes.detach(volume)
TempestClients.cinder().volumes.force_delete(volume)
except Exception:
TempestClients.cinder().volumes.force_delete(volume)
wait_for_status(30, _check_num_volumes, num_volumes=0)
time.sleep(2)
def _check_num_volumes(num_volumes=0, state=''):
if len(TempestClients.cinder().volumes.list()) != num_volumes:
return False
return all(volume.__dict__['status'].upper() == state.upper() and
len(volume.__dict__['attachments']) == 1
for volume in TempestClients.cinder().volumes.list())

18
vitrage_tempest_tests/tests/common/glance_utils.py Normal file
View File

@ -0,0 +1,18 @@
# Copyright 2017 - Nokia
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
def get_first_image():
return TempestClients.glance().images.list().next()

61
vitrage_tempest_tests/tests/common/heat_utils.py Normal file
View File

@ -0,0 +1,61 @@
# Copyright 2017 - Nokia
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import time
from heatclient.common import http
from heatclient.common import template_utils
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
from vitrage_tempest_tests.tests.utils import wait_for_status
def create_stacks(num_stacks, nested, template_file):
tpl_files, template = template_utils.process_template_path(
template_file,
object_request=http.authenticated_fetcher(TempestClients.heat()))
for i in range(num_stacks):
stack_name = 'stack_%s' % i + ('_nested' if nested else '')
TempestClients.heat().stacks.create(stack_name=stack_name,
template=template,
files=tpl_files,
parameters={})
wait_for_status(45,
_check_num_stacks,
num_stacks=num_stacks,
state='CREATE_COMPLETE')
time.sleep(2)
def delete_all_stacks():
stacks = TempestClients.heat().stacks.list()
for stack in stacks:
try:
TempestClients.heat().stacks.delete(stack.to_dict()['id'])
except Exception:
pass
wait_for_status(30, _check_num_stacks, num_stacks=0)
time.sleep(4)
def _check_num_stacks(num_stacks, state=''):
stacks_list = \
[stack.to_dict() for stack in TempestClients.heat().stacks.list()
if 'FAILED' not in stack.to_dict()['stack_status']]
if len(stacks_list) != num_stacks:
return False
return all(stack['stack_status'].upper() == state.upper()
for stack in stacks_list)

23
vitrage_tempest_tests/tests/common/neutron_utils.py Normal file
View File

@ -0,0 +1,23 @@
# Copyright 2017 - Nokia
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from vitrage.common.constants import VertexProperties as VProps
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
from vitrage_tempest_tests.tests.utils import uni2str
def get_public_network():
nets = TempestClients.neutron().list_networks()
return next(
(n for n in nets['networks'] if uni2str(n[VProps.NAME]) == 'public'),
None)

62
vitrage_tempest_tests/tests/common/nova_utils.py Normal file
View File

@ -0,0 +1,62 @@
# Copyright 2017 - Nokia
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import time
from vitrage_tempest_tests.tests.common import glance_utils
from vitrage_tempest_tests.tests.common import neutron_utils
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
from vitrage_tempest_tests.tests.utils import wait_for_status
def create_instances(num_instances, set_public_network=False, name='vm'):
kwargs = {}
flavor = get_first_flavor()
image = glance_utils.get_first_image()
if set_public_network:
public_net = neutron_utils.get_public_network()
if public_net:
kwargs.update({"networks": [{'uuid': public_net['id']}]})
resources = [TempestClients.nova().servers.create(
name='%s-%s' % (name, index),
flavor=flavor,
image=image,
**kwargs) for index in range(num_instances)]
wait_for_status(30, _check_num_instances, num_instances=num_instances,
state='active')
time.sleep(2)
return resources
def delete_all_instances():
instances = TempestClients.nova().servers.list()
for instance in instances:
try:
TempestClients.nova().servers.delete(instance)
except Exception:
pass
wait_for_status(30, _check_num_instances, num_instances=0)
time.sleep(2)
def get_first_flavor():
return TempestClients.nova().flavors.list()[0]
def _check_num_instances(num_instances=0, state=''):
if len(TempestClients.nova().servers.list()) != num_instances:
return False
return all(instance.__dict__['status'].upper() == state.upper()
for instance in TempestClients.nova().servers.list())

80
vitrage_tempest_tests/tests/common/tempest_clients.py Normal file
View File

@ -0,0 +1,80 @@
# Copyright 2016 Nokia
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from vitrage import keystone_client
from vitrage import os_clients
from vitrageclient import client as vc
class TempestClients(object):
@classmethod
def class_init(cls, conf):
cls._conf = conf
cls._vitrage = None
cls._ceilometer = None
cls._nova = None
cls._cinder = None
cls._glance = None
cls._neutron = None
cls._heat = None
cls._mistral = None
@classmethod
def vitrage(cls):
if not cls._vitrage:
cls._vitrage = vc.Client(
'1', session=keystone_client.get_session(cls._conf))
return cls._vitrage
@classmethod
def ceilometer(cls):
if not cls._ceilometer:
cls._ceilometer = os_clients.ceilometer_client(cls._conf)
return cls._ceilometer
@classmethod
def nova(cls):
if not cls._nova:
cls._nova = os_clients.nova_client(cls._conf)
return cls._nova
@classmethod
def cinder(cls):
if not cls._cinder:
cls._cinder = os_clients.cinder_client(cls._conf)
return cls._cinder
@classmethod
def glance(cls):
if not cls._glance:
cls._glance = os_clients.glance_client(cls._conf)
return cls._glance
@classmethod
def neutron(cls):
if not cls._neutron:
cls._neutron = os_clients.neutron_client(cls._conf)
return cls._neutron
@classmethod
def heat(cls):
if not cls._heat:
cls._heat = os_clients.heat_client(cls._conf)
return cls._heat
@classmethod
def mistral(cls):
if not cls._mistral:
cls._mistral = os_clients.mistral_client(cls._conf)
return cls._mistral

23
vitrage_tempest_tests/tests/common/vitrage_utils.py Normal file
View File

@ -0,0 +1,23 @@
# Copyright 2017 - Nokia
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from vitrage.common.constants import VertexProperties as VProps
from vitrage.datasources import NOVA_HOST_DATASOURCE
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
def get_first_host():
nodes = TempestClients.vitrage().topology.get(all_tenants=True)['nodes']
return next(
(n for n in nodes if n[VProps.VITRAGE_TYPE] == NOVA_HOST_DATASOURCE),
None)

0
vitrage_tempest_tests/tests/api/datasources/__init__.py → vitrage_tempest_tests/tests/datasources/__init__.py
View File

18
vitrage_tempest_tests/tests/api/datasources/test_aodh.py → vitrage_tempest_tests/tests/datasources/test_aodh.py
View File

@ -16,6 +16,9 @@ from oslo_log import log as logging
from vitrage_tempest_tests.tests import utils from vitrage_tempest_tests.tests import utils
from vitrage_tempest_tests.tests.api.alarms.base import BaseAlarmsTest from vitrage_tempest_tests.tests.api.alarms.base import BaseAlarmsTest
from vitrage_tempest_tests.tests.common import ceilometer_utils
from vitrage_tempest_tests.tests.common import nova_utils
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -32,8 +35,9 @@ class TestAodhAlarm(BaseAlarmsTest):
def test_alarm_with_resource_id(self): def test_alarm_with_resource_id(self):
try: try:
# Action # Action
self._create_instances(num_instances=self.NUM_INSTANCE) nova_utils.create_instances(num_instances=self.NUM_INSTANCE)
self._create_ceilometer_alarm(self._find_instance_resource_id()) ceilometer_utils.create_ceilometer_alarm(
self._find_instance_resource_id())
# Calculate expected results # Calculate expected results
api_graph = self.vitrage_client.topology.get(all_tenants=True) api_graph = self.vitrage_client.topology.get(all_tenants=True)
@ -60,14 +64,14 @@ class TestAodhAlarm(BaseAlarmsTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_ceilometer_alarms() ceilometer_utils.delete_all_ceilometer_alarms()
self._delete_instances() nova_utils.delete_all_instances()
@utils.tempest_logger @utils.tempest_logger
def test_alarm_without_resource_id(self): def test_alarm_without_resource_id(self):
try: try:
# Action # Action
self._create_ceilometer_alarm() ceilometer_utils.create_ceilometer_alarm()
# Calculate expected results # Calculate expected results
api_graph = self.vitrage_client.topology.get(all_tenants=True) api_graph = self.vitrage_client.topology.get(all_tenants=True)
@ -90,8 +94,8 @@ class TestAodhAlarm(BaseAlarmsTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_ceilometer_alarms() ceilometer_utils.delete_all_ceilometer_alarms()
def _find_instance_resource_id(self): def _find_instance_resource_id(self):
servers = self.nova_client.servers.list() servers = TempestClients.nova().servers.list()
return servers[0].id return servers[0].id

0
vitrage_tempest_tests/tests/api/datasources/test_cinder_volume.py → vitrage_tempest_tests/tests/datasources/test_cinder_volume.py
View File

64
vitrage_tempest_tests/tests/api/datasources/test_heat_stack.py → vitrage_tempest_tests/tests/datasources/test_heat_stack.py
View File

@ -12,14 +12,11 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import time
from heatclient.common import http
from heatclient.common import template_utils
from oslo_log import log as logging from oslo_log import log as logging
from vitrage_tempest_tests.tests import utils from vitrage_tempest_tests.tests import utils
from vitrage_tempest_tests.tests.api.topology.base import BaseTopologyTest from vitrage_tempest_tests.tests.api.topology.base import BaseTopologyTest
from vitrage_tempest_tests.tests.common import heat_utils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -33,13 +30,16 @@ class TestHeatStack(BaseTopologyTest):
@utils.tempest_logger @utils.tempest_logger
def test_nested_heat_stack(self): def test_nested_heat_stack(self):
self._test_heat_stack(nested=True) self._test_heat_stack(
nested=True,
template_file='/etc/vitrage/heat_nested_template.yaml')
@utils.tempest_logger @utils.tempest_logger
def test_heat_stack(self): def test_heat_stack(self):
self._test_heat_stack(nested=False) self._test_heat_stack(
nested=False, template_file='/etc/vitrage/heat_template.yaml')
def _test_heat_stack(self, nested): def _test_heat_stack(self, nested, template_file):
"""heat stack test """heat stack test
This test validate correctness topology graph with heat stack module This test validate correctness topology graph with heat stack module
@ -47,7 +47,7 @@ class TestHeatStack(BaseTopologyTest):
try: try:
# Action # Action
self._create_stacks(self.NUM_STACKS, nested) heat_utils.create_stacks(self.NUM_STACKS, nested, template_file)
# Calculate expected results # Calculate expected results
api_graph = self.vitrage_client.topology.get(all_tenants=True) api_graph = self.vitrage_client.topology.get(all_tenants=True)
@ -77,50 +77,4 @@ class TestHeatStack(BaseTopologyTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_stacks() heat_utils.delete_all_stacks()
def _create_stacks(self, num_stacks, nested):
template_file = 'heat_nested_template.yaml'\
if nested else 'heat_template.yaml'
tpl_files, template = template_utils.process_template_path(
'/etc/vitrage/' + template_file,
object_request=http.authenticated_fetcher(self.heat_client))
for i in range(num_stacks):
stack_name = 'stack_%s' % i + ('_nested' if nested else '')
self.heat_client.stacks.create(stack_name=stack_name,
template=template,
files=tpl_files,
parameters={})
self._wait_for_status(45,
self._check_num_stacks,
num_stacks=num_stacks,
state='CREATE_COMPLETE')
time.sleep(2)
def _delete_stacks(self):
stacks = self.heat_client.stacks.list()
for stack in stacks:
try:
self.heat_client.stacks.delete(stack.to_dict()['id'])
except Exception:
pass
self._wait_for_status(30,
self._check_num_stacks,
num_stacks=0)
time.sleep(4)
def _check_num_stacks(self, num_stacks, state=''):
stacks_list = \
[stack.to_dict() for stack in self.heat_client.stacks.list()
if 'FAILED' not in stack.to_dict()['stack_status']]
if len(stacks_list) != num_stacks:
return False
return all(stack['stack_status'].upper() == state.upper()
for stack in stacks_list)

7
vitrage_tempest_tests/tests/api/datasources/test_neutron.py → vitrage_tempest_tests/tests/datasources/test_neutron.py
View File

@ -16,6 +16,7 @@ from oslo_log import log as logging
from vitrage.common.constants import VertexProperties as VProps from vitrage.common.constants import VertexProperties as VProps
from vitrage_tempest_tests.tests.api.topology.base import BaseTopologyTest from vitrage_tempest_tests.tests.api.topology.base import BaseTopologyTest
from vitrage_tempest_tests.tests.common import nova_utils
from vitrage_tempest_tests.tests import utils from vitrage_tempest_tests.tests import utils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -37,8 +38,8 @@ class TestNeutron(BaseTopologyTest):
try: try:
# Action # Action
self._create_instances(num_instances=self.NUM_INSTANCE, nova_utils.create_instances(num_instances=self.NUM_INSTANCE,
set_public_network=True) set_public_network=True)
# Calculate expected results # Calculate expected results
api_graph = self.vitrage_client.topology.get(all_tenants=True) api_graph = self.vitrage_client.topology.get(all_tenants=True)
@ -67,7 +68,7 @@ class TestNeutron(BaseTopologyTest):
self._handle_exception(e) self._handle_exception(e)
raise raise
finally: finally:
self._delete_instances() nova_utils.delete_all_instances()
@staticmethod @staticmethod
def _get_network_name(instance, networks): def _get_network_name(instance, networks):

0
vitrage_tempest_tests/tests/api/datasources/test_nova.py → vitrage_tempest_tests/tests/datasources/test_nova.py
View File

5
vitrage_tempest_tests/tests/api/datasources/test_static_physical.py → vitrage_tempest_tests/tests/datasources/test_static_physical.py
View File

@ -17,14 +17,13 @@ import socket
import time import time
from oslo_log import log as logging from oslo_log import log as logging
from vitrage_tempest_tests.tests.api.base import BaseApiTest from vitrage_tempest_tests.tests.base import BaseVitrageTempest
from vitrage_tempest_tests.tests import utils from vitrage_tempest_tests.tests import utils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
class TestStaticPhysical(BaseApiTest): class TestStaticPhysical(BaseVitrageTempest):
NUM_SWITCH = 2 NUM_SWITCH = 2
@classmethod @classmethod

37
vitrage_tempest_tests/tests/notifiers/test_mistral_notifier.py
View File

@ -19,8 +19,10 @@ from vitrage import os_clients
from vitrage_tempest_tests.tests.api.event.base import BaseTestEvents from vitrage_tempest_tests.tests.api.event.base import BaseTestEvents
from vitrage_tempest_tests.tests.api.event.base import DOWN from vitrage_tempest_tests.tests.api.event.base import DOWN
from vitrage_tempest_tests.tests.api.event.base import UP from vitrage_tempest_tests.tests.api.event.base import UP
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
from vitrage_tempest_tests.tests.common import vitrage_utils
from vitrage_tempest_tests.tests import utils from vitrage_tempest_tests.tests import utils
from vitrage_tempest_tests.tests.utils import wait_for_answer from vitrage_tempest_tests.tests.utils import wait_for_status
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -51,7 +53,7 @@ class TestMistralNotifier(BaseTestEvents):
@utils.tempest_logger @utils.tempest_logger
def test_execute_mistral(self): def test_execute_mistral(self):
hostname = self._get_host()['name'] hostname = vitrage_utils.get_first_host()['name']
workflows = self.mistral_client.workflows.list() workflows = self.mistral_client.workflows.list()
self.assertIsNotNone(workflows) self.assertIsNotNone(workflows)
@ -61,7 +63,7 @@ class TestMistralNotifier(BaseTestEvents):
self.assertIsNotNone(executions) self.assertIsNotNone(executions)
num_executions = len(executions) num_executions = len(executions)
alarms = wait_for_answer(2, 0.5, self._check_alarms) alarms = utils.wait_for_answer(2, 0.5, self._check_alarms)
self.assertIsNotNone(alarms) self.assertIsNotNone(alarms)
num_alarms = len(alarms) num_alarms = len(alarms)
@ -81,16 +83,16 @@ class TestMistralNotifier(BaseTestEvents):
self._post_event(details) self._post_event(details)
# Wait for the alarm to be raised # Wait for the alarm to be raised
self.assertTrue( self.assertTrue(wait_for_status(
self._wait_for_status(10, 10,
self._check_num_vitrage_alarms, self._check_num_vitrage_alarms,
num_alarms=num_alarms + 1)) num_alarms=num_alarms + 1))
# Wait for the Mistral workflow execution # Wait for the Mistral workflow execution
self.assertTrue( self.assertTrue(wait_for_status(
self._wait_for_status(20, 20,
self._check_mistral_workflow_execution, self._check_mistral_workflow_execution,
num_executions=num_executions + 1)) num_executions=num_executions + 1))
except Exception as e: except Exception as e:
self._handle_exception(e) self._handle_exception(e)
@ -113,14 +115,15 @@ class TestMistralNotifier(BaseTestEvents):
details = self._create_doctor_event_details(hostname, UP) details = self._create_doctor_event_details(hostname, UP)
self._post_event(details) self._post_event(details)
self.assertTrue( self.assertTrue(wait_for_status(
self._wait_for_status(10, 10,
self._check_num_vitrage_alarms, self._check_num_vitrage_alarms,
num_alarms=num_alarms)) num_alarms=num_alarms))
def _check_num_vitrage_alarms(self, num_alarms): def _check_num_vitrage_alarms(self, num_alarms):
if len(self.vitrage_client.alarm.list(vitrage_id='all', vitrage_alarms = TempestClients.vitrage().alarm.list(vitrage_id='all',
all_tenants=True)) == num_alarms: all_tenants=True)
if len(vitrage_alarms) == num_alarms:
return True return True
return False return False

11
vitrage_tempest_tests/tests/utils.py
View File

@ -159,3 +159,14 @@ def wait_for_answer(max_waiting, time_between_attempts, func, **kwargs):
return res return res
LOG.info("wait for answer- False") LOG.info("wait for answer- False")
return res return res
def wait_for_status(max_waiting, func, **kwargs):
count = 0
while count < max_waiting:
if func(**kwargs):
return True
count += 1
time.sleep(2)
LOG.info("wait_for_status - False")
return False