Merge "make test more readable"

vitrage_tempest_plugin/tests/api/alarms/test_alarms.py

@@ -15,9 +15,11 @@
 import json
 
 from oslo_log import log as logging
+from testtools import matchers
 
 from vitrage.datasources.aodh import AODH_DATASOURCE
 from vitrage_tempest_plugin.tests.api.alarms.base import BaseAlarmsTest
+from vitrage_tempest_plugin.tests.base import IsNotEmpty
 from vitrage_tempest_plugin.tests.common import aodh_utils
 from vitrage_tempest_plugin.tests.common import general_utils as g_utils
 from vitrage_tempest_plugin.tests.common import nova_utils
@@ -56,8 +58,8 @@ class TestAlarms(BaseAlarmsTest):
         try:
             instances = nova_utils.create_instances(num_instances=1,
                                                     set_public_network=True)
-            self.assertNotEqual(len(instances), 0,
+            self.assertThat(instances, IsNotEmpty(),
-                                'The instances list is empty')
+                            'The instances list is empty')
             aodh_utils.create_aodh_alarm(
                 resource_id=instances[0].id,
                 name='tempest_aodh_test')
@@ -79,10 +81,10 @@ class TestAlarms(BaseAlarmsTest):
     def _compare_alarms_lists(self, api_alarms, cli_alarms,
                               resource_type, resource_id):
         """Validate alarm existence """
-        self.assertNotEqual(len(api_alarms), 0,
+        self.assertThat(api_alarms, IsNotEmpty(),
-                            'The alarms list taken from api is empty')
+                        'The alarms list taken from api is empty')
-        self.assertIsNotNone(cli_alarms,
+        self.assertThat(cli_alarms, IsNotEmpty(),
-                             'The alarms list taken from cli is empty')
+                        'The alarms list taken from cli is empty')
 
         LOG.info("The alarms list taken from cli is : " +
                  str(cli_alarms))
@@ -99,5 +101,5 @@ class TestAlarms(BaseAlarmsTest):
         cli_by_id = cli_alarms.count(resource_id)
 
         self.assertEqual(len(cli_items), len(api_alarms) + 4)
-        self.assertEqual(cli_by_type, len(api_by_type))
+        self.assertThat(api_by_type, matchers.HasLength(cli_by_type))
-        self.assertEqual(cli_by_id, len(api_by_id))
+        self.assertThat(api_by_id, matchers.HasLength(cli_by_id))

vitrage_tempest_plugin/tests/api/event/test_events.py

@@ -16,15 +16,16 @@ import six
 
 from datetime import datetime
 from oslo_log import log as logging
+from testtools import matchers
 
 from vitrage.common.constants import EntityCategory
 from vitrage.common.constants import EventProperties as EventProps
 from vitrage.common.constants import VertexProperties as VProps
 from vitrage_tempest_plugin.tests.api.event.base import BaseTestEvents
+from vitrage_tempest_plugin.tests.base import IsEmpty
 from vitrage_tempest_plugin.tests.common.vitrage_utils import DOWN
 from vitrage_tempest_plugin.tests.utils import wait_for_answer
 
-
 LOG = logging.getLogger(__name__)
 
 
@@ -51,8 +52,8 @@ class TestEvents(BaseTestEvents):
             api_alarms = wait_for_answer(2, 0.5, self._check_alarms)
 
             # expect to get a 'host down alarm', generated by Doctor datasource
-            self.assertIsNotNone(api_alarms, 'Expected host down alarm')
+            self.assertThat(api_alarms, matchers.HasLength(1),
-            self.assertEqual(1, len(api_alarms), 'Expected host down alarm')
+                            'Expected host down alarm')
 
             alarm = api_alarms[0]
             event_time_tz = six.u(event_time.strftime('%Y-%m-%dT%H:%M:%SZ'))
@@ -65,7 +66,7 @@ class TestEvents(BaseTestEvents):
 
             api_alarms = wait_for_answer(2, 0.5, self._check_alarms)
             self.assertIsNotNone(api_alarms, 'Expected host down alarm')
-            self.assertEqual(0, len(api_alarms), 'Expected host down alarm')
+            self.assertThat(api_alarms, IsEmpty(), 'Expected host down alarm')
 
         except Exception as e:
             LOG.exception(e)

vitrage_tempest_plugin/tests/api/rca/base.py

@@ -15,6 +15,7 @@
 import json
 
 from oslo_log import log as logging
+from testtools import matchers
 
 from vitrage.common.constants import EdgeLabel
 from vitrage.common.constants import EdgeProperties
@@ -29,6 +30,7 @@ from vitrage.entity_graph.mappings.operational_resource_state \
 from vitrage.evaluator.actions.evaluator_event_transformer \
     import VITRAGE_DATASOURCE
 from vitrage_tempest_plugin.tests.api.alarms.base import BaseAlarmsTest
+from vitrage_tempest_plugin.tests.base import IsNotEmpty
 from vitrage_tempest_plugin.tests.common import aodh_utils
 from vitrage_tempest_plugin.tests.common import general_utils as g_utils
 from vitrage_tempest_plugin.tests.common import nova_utils
@@ -72,7 +74,8 @@ class BaseRcaTest(BaseAlarmsTest):
         return expected_alarm[0]
 
     def _compare_rca(self, api_rca, cli_rca):
-        self.assertNotEqual(len(api_rca), 0, 'The rca taken from api is empty')
+        self.assertThat(api_rca, IsNotEmpty(),
+                        'The rca taken from api is empty')
         self.assertIsNotNone(cli_rca, 'The rca taken from cli is empty')
 
         LOG.info("The rca taken from cli is : " + str(cli_rca))
@@ -84,7 +87,7 @@ class BaseRcaTest(BaseAlarmsTest):
         self.assertEqual(sorted_cli_graph, sorted_api_graph)
 
     def _validate_rca(self, rca):
-        self.assertNotEqual(len(rca), 0, 'The rca is empty')
+        self.assertThat(rca, IsNotEmpty, 'The rca is empty')
         LOG.info("The rca alarms list is : " + str(json.dumps(rca)))
 
         resource_alarm = g_utils.all_matches(
@@ -98,13 +101,13 @@ class BaseRcaTest(BaseAlarmsTest):
             name=VITRAGE_ALARM_NAME,
             severity=OperationalAlarmSeverity.WARNING)
 
-        self.assertEqual(3, len(rca))
+        self.assertThat(rca, matchers.HasLength(3))
-        self.assertEqual(1, len(resource_alarm))
+        self.assertThat(resource_alarm, matchers.HasLength(1))
-        self.assertEqual(2, len(deduce_alarms))
+        self.assertThat(deduce_alarms, matchers.HasLength(2))
 
     def _validate_deduce_alarms(self, alarms, instances):
         """Validate alarm existence """
-        self.assertNotEqual(len(alarms), 0, 'The alarms list is empty')
+        self.assertThat(alarms, IsNotEmpty(), 'The alarms list is empty')
         LOG.info("The alarms list is : " + str(json.dumps(alarms)))
 
         # Find the vitrage_id of the deduced alarms using their original id.
@@ -131,14 +134,16 @@ class BaseRcaTest(BaseAlarmsTest):
             vitrage_resource_type=NOVA_INSTANCE_DATASOURCE,
             vitrage_resource_id=vitrage_instance_1_id[VProps.VITRAGE_ID])
 
-        self.assertEqual(3, len(alarms), "Expected 3 alarms - 1 on host and "
+        self.assertThat(alarms, matchers.HasLength(3),
-                                         "2 deduced")
+                        "Expected 3 alarms - 1 on host and 2 deduced")
-        self.assertEqual(1, len(deduce_alarms_1), "Deduced alarm not found")
+        self.assertThat(deduce_alarms_1, matchers.HasLength(1),
-        self.assertEqual(1, len(deduce_alarms_2), "Deduced alarm not found")
+                        "Deduced alarm not found")
+        self.assertThat(deduce_alarms_2, matchers.HasLength(1),
+                        "Deduced alarm not found")
 
     def _validate_relationship(self, links, alarms):
-        self.assertNotEqual(len(links), 0, 'The links list is empty')
+        self.assertThat(links, IsNotEmpty(), 'The links list is empty')
-        self.assertNotEqual(len(alarms), 0, 'The alarms list is empty')
+        self.assertThat(alarms, IsNotEmpty(), 'The alarms list is empty')
 
         flag = True
         for item in links:
@@ -150,11 +155,11 @@ class BaseRcaTest(BaseAlarmsTest):
                     or target_alarm_name != VITRAGE_ALARM_NAME:
                 flag = False
 
-        self.assertEqual(3, len(alarms))
+        self.assertThat(alarms, matchers.HasLength(3))
         self.assertTrue(flag)
 
     def _validate_set_state(self, topology, instances):
-        self.assertNotEqual(len(topology), 0, 'The topology graph is empty')
+        self.assertThat(topology, IsNotEmpty(), 'The topology graph is empty')
         host = g_utils.all_matches(
             topology,
             vitrage_type=NOVA_HOST_DATASOURCE,
@@ -176,14 +181,14 @@ class BaseRcaTest(BaseAlarmsTest):
             vitrage_state=OperationalResourceState.SUBOPTIMAL,
             vitrage_aggregated_state=OperationalResourceState.SUBOPTIMAL)
 
-        self.assertEqual(1, len(host))
+        self.assertThat(host, matchers.HasLength(1))
-        self.assertEqual(1, len(vm1))
+        self.assertThat(vm1, matchers.HasLength(1))
-        self.assertEqual(1, len(vm2))
+        self.assertThat(vm2, matchers.HasLength(1))
 
     def _validate_notifier(self, alarms, vitrage_alarms):
-        self.assertNotEqual(len(alarms), 0, 'The aodh alarms list is empty')
+        self.assertThat(alarms, IsNotEmpty(), 'The aodh alarms list is empty')
-        self.assertNotEqual(len(vitrage_alarms), 0,
+        self.assertThat(vitrage_alarms, IsNotEmpty(),
-                            'The vitrage alarms list is empty')
+                        'The vitrage alarms list is empty')
 
         validation = 0
         for itemC in alarms:
@@ -199,8 +204,8 @@ class BaseRcaTest(BaseAlarmsTest):
                     validation += 1
                     break
 
-        self.assertEqual(validation, len(vitrage_alarms))
+        self.assertThat(vitrage_alarms, matchers.HasLength(validation))
-        self.assertEqual(3, len(alarms))
+        self.assertThat(alarms, matchers.HasLength(3))
 
     def _get_hostname(self):
         host = vitrage_utils.get_first_host()

vitrage_tempest_plugin/tests/api/rca/test_rca.py

@@ -17,6 +17,7 @@ from oslo_log import log as logging
 from vitrage.common.constants import VertexProperties as VProps
 from vitrage_tempest_plugin.tests.api.rca.base import BaseRcaTest
 from vitrage_tempest_plugin.tests.api.rca.base import RCA_ALARM_NAME
+from vitrage_tempest_plugin.tests.base import IsNotEmpty
 from vitrage_tempest_plugin.tests.common import nova_utils
 from vitrage_tempest_plugin.tests.common.tempest_clients import TempestClients
 from vitrage_tempest_plugin.tests.common import vitrage_utils as v_utils
@@ -57,7 +58,8 @@ class TestRca(BaseRcaTest):
         try:
             instances = nova_utils.create_instances(num_instances=1,
                                                     set_public_network=True)
-            self.assertNotEqual(len(instances), 0, 'Failed to create instance')
+            self.assertThat(instances, IsNotEmpty(),
+                            'Failed to create instance')
 
             instance_alarm = self._create_alarm(
                 resource_id=instances[0].id,

vitrage_tempest_plugin/tests/api/resources/test_resources.py

@@ -15,13 +15,15 @@
 import json
 
 from oslo_log import log as logging
-
+from testtools import matchers
 import unittest
 
 from vitrage.common.constants import VertexProperties as VProps
 from vitrage.datasources import CINDER_VOLUME_DATASOURCE
 from vitrage.datasources import NOVA_INSTANCE_DATASOURCE
 from vitrage_tempest_plugin.tests.base import BaseVitrageTempest
+from vitrage_tempest_plugin.tests.base import IsEmpty
+from vitrage_tempest_plugin.tests.base import IsNotEmpty
 from vitrage_tempest_plugin.tests.common import nova_utils
 from vitrage_tempest_plugin.tests import utils
 from vitrageclient.exceptions import ClientException
@@ -54,8 +56,8 @@ class TestResource(BaseVitrageTempest):
         try:
             instances = nova_utils.create_instances(num_instances=1,
                                                     set_public_network=True)
-            self.assertNotEqual(len(instances), 0,
+            self.assertThat(instances, IsNotEmpty(),
-                                'The instances list is empty')
+                            'The instances list is empty')
             api_resources = self.vitrage_client.resource.list(
                 all_tenants=True)
 
@@ -80,10 +82,10 @@ class TestResource(BaseVitrageTempest):
         try:
             instances = nova_utils.create_instances(num_instances=1,
                                                     set_public_network=True)
-            self.assertNotEqual(len(instances), 0,
+            self.assertThat(instances, IsNotEmpty(),
-                                'The instances list is empty')
+                            'The instances list is empty')
             resources = self.vitrage_client.resource.list(all_tenants=False)
-            self.assertEqual(3, len(resources))
+            self.assertThat(resources, matchers.HasLength(3))
         except Exception as e:
             self._handle_exception(e)
             raise
@@ -102,8 +104,8 @@ class TestResource(BaseVitrageTempest):
                 all_tenants=True)
             instances = nova_utils.create_instances(num_instances=1,
                                                     set_public_network=True)
-            self.assertNotEqual(len(instances), 0,
+            self.assertThat(instances, IsNotEmpty(),
-                                'The instances list is empty')
+                            'The instances list is empty')
             resources = self.vitrage_client.resource.list(all_tenants=True)
 
             self.assertEqual(len(resources_before) + 2, len(resources))
@@ -122,12 +124,12 @@ class TestResource(BaseVitrageTempest):
         try:
             instances = nova_utils.create_instances(num_instances=1,
                                                     set_public_network=True)
-            self.assertNotEqual(len(instances), 0,
+            self.assertThat(instances, IsNotEmpty(),
-                                'The instances list is empty')
+                            'The instances list is empty')
             resources = self.vitrage_client.resource.list(
                 resource_type=NOVA_INSTANCE_DATASOURCE,
                 all_tenants=True)
-            self.assertEqual(1, len(resources))
+            self.assertThat(resources, matchers.HasLength(1))
         except Exception as e:
             self._handle_exception(e)
             raise
@@ -140,12 +142,12 @@ class TestResource(BaseVitrageTempest):
         try:
             instances = nova_utils.create_instances(num_instances=1,
                                                     set_public_network=True)
-            self.assertNotEqual(len(instances), 0,
+            self.assertThat(instances, IsNotEmpty(),
-                                'The instances list is empty')
+                            'The instances list is empty')
             resources = self.vitrage_client.resource.list(
                 resource_type=CINDER_VOLUME_DATASOURCE,
                 all_tenants=True)
-            self.assertEqual(0, len(resources))
+            self.assertThat(resources, IsEmpty())
         except Exception as e:
             self._handle_exception(e)
             raise
@@ -156,7 +158,7 @@ class TestResource(BaseVitrageTempest):
     def test_compare_resource_show(self):
         """resource_show test"""
         resource_list = self.vitrage_client.resource.list(all_tenants=False)
-        self.assertNotEqual(len(resource_list), 0)
+        self.self.assertThat(resource_list, IsNotEmpty())
         for resource in resource_list:
             api_resource_show = \
                 self.vitrage_client.resource.get(resource[VProps.VITRAGE_ID])
@@ -181,10 +183,10 @@ class TestResource(BaseVitrageTempest):
             nova_utils.delete_all_instances()
 
     def _compare_resources(self, api_resources, cli_resources):
-        self.assertNotEqual(len(api_resources), 0,
+        self.assertThat(api_resources, IsNotEmpty(),
-                            'The resources taken from rest api is empty')
+                        'The resources taken from rest api is empty')
-        self.assertNotEqual(len(cli_resources), 0,
+        self.assertThat(cli_resources, IsNotEmpty(),
-                            'The resources taken from terminal is empty')
+                        'The resources taken from rest api is empty')
 
         sorted_cli_resources = sorted(
             json.loads(cli_resources),

vitrage_tempest_plugin/tests/api/templates/base.py

@@ -14,9 +14,11 @@
 import json
 
 from oslo_log import log as logging
+from testtools import matchers
 
 from vitrage.common.exception import VitrageError
 from vitrage_tempest_plugin.tests.base import BaseVitrageTempest
+from vitrage_tempest_plugin.tests.base import IsNotEmpty
 from vitrage_tempest_plugin.tests.common import general_utils as g_utils
 from vitrage_tempest_plugin.tests.common import vitrage_utils
 from vitrage_tempest_plugin.tests import utils
@@ -51,8 +53,8 @@ class BaseTemplateTest(BaseVitrageTempest):
         super(BaseTemplateTest, cls).setUpClass()
 
     def _compare_template_lists(self, api_templates, cli_templates):
-        self.assertNotEqual(len(api_templates), 0,
+        self.assertThat(api_templates, IsNotEmpty(),
-                            'The template list taken from api is empty')
+                        'The template list taken from api is empty')
         self.assertIsNotNone(cli_templates,
                              'The template list taken from cli is empty')
 
@@ -67,8 +69,8 @@ class BaseTemplateTest(BaseVitrageTempest):
         self._validate_templates_existence_in_default_folder(api_templates)
 
     def _compare_template_validations(self, api_templates, cli_templates):
-        self.assertNotEqual(len(api_templates), 0,
+        self.assertThat(api_templates, IsNotEmpty(),
-                            'The template validations taken from api is empty')
+                        'The template validations taken from api is empty')
         self.assertIsNotNone(
             cli_templates, 'The template validations taken from cli is empty')
 
@@ -91,7 +93,8 @@ class BaseTemplateTest(BaseVitrageTempest):
             api_templates,
             **{'status details': self.OK_MSG})
         cli_passes_templates = cli_templates.count(' ' + self.OK_MSG + ' ')
-        self.assertEqual(cli_passes_templates, len(api_passes_templates))
+        self.assertThat(api_passes_templates,
+                        matchers.HasLength(cli_passes_templates))
 
     def _compare_each_template_in_list(self, api_templates, cli_templates):
         counter = 0
@@ -102,7 +105,7 @@ class BaseTemplateTest(BaseVitrageTempest):
                 if name_start > 0 and status_start > 0:
                     counter += 1
                     break
-        self.assertEqual(counter, len(api_templates))
+        self.assertThat(api_templates, matchers.HasLength(counter))
 
     def _validate_templates_existence_in_default_folder(self, templates_list):
         counter = 0
@@ -111,12 +114,12 @@ class BaseTemplateTest(BaseVitrageTempest):
             name_start = text_out.count(' ' + item['name'] + ' ')
             if name_start > -1:
                 counter += 1
-        self.assertEqual(counter, len(templates_list))
+        self.assertThat(templates_list, matchers.HasLength(counter))
 
     def _run_default_template_validation(
             self, template, validation, path):
-        self.assertNotEqual(len(validation), 0,
+        self.assertThat(validation, IsNotEmpty(),
-                            'The template validation is empty')
+                        'The template validation is empty')
         self.assertEqual(path, validation['file path'])
         self.assertEqual(0, validation['status code'])
         self.assertEqual(self.OK_STATUS, validation['status'])
@@ -138,8 +141,8 @@ class BaseTemplateTest(BaseVitrageTempest):
         self.assertEqual(self.OK_MSG, validation['message'])
 
     def _compare_template_show(self, api_templates, cli_templates):
-        self.assertNotEqual(len(api_templates), 0,
+        self.assertThat(api_templates, IsNotEmpty(),
-                            'The template validations taken from api is empty')
+                        'The template validations taken from api is empty')
         self.assertIsNotNone(
             cli_templates, 'The template validations taken from cli is empty')
 
@@ -163,14 +166,13 @@ class BaseTemplateTest(BaseVitrageTempest):
         relationships = template_content.count('relationship:')
         scenarios = template_content.count('scenario:')
 
-        self.assertIn(
+        self.assertIn(template_show['metadata']['name'], template_content)
-            template_show['metadata']['name'], template_content)
+        self.assertThat(template_show['definitions']['entities'],
-        self.assertEqual(
+                        matchers.HasLength(entities))
-            entities, len(template_show['definitions']['entities']))
+        self.assertThat(template_show['definitions']['relationships'],
-        self.assertEqual(
+                        matchers.HasLength(relationships))
-            relationships, len(template_show['definitions']['relationships']))
+        self.assertThat(template_show['scenarios'],
-        self.assertEqual(
+                        matchers.HasLength(scenarios))
-            scenarios, len(template_show['scenarios']))
 
     def _rollback_to_default(self, templates):
         try:

vitrage_tempest_plugin/tests/api/templates/test_template.py

@@ -15,14 +15,17 @@
 import unittest
 
 from oslo_log import log as logging
+from testtools import matchers
 
 from vitrage.common.constants import TemplateStatus
 from vitrage.common.constants import TemplateTypes as TTypes
 from vitrage.utils import file
 from vitrage_tempest_plugin.tests.api.templates.base import BaseTemplateTest
+from vitrage_tempest_plugin.tests.base import IsNotEmpty
 from vitrage_tempest_plugin.tests.common import general_utils as g_utils
 from vitrage_tempest_plugin.tests.common.tempest_clients import TempestClients
 from vitrage_tempest_plugin.tests.common import vitrage_utils as v_utils
+
 import vitrage_tempest_plugin.tests.utils as utils
 
 LOG = logging.getLogger(__name__)
@@ -92,7 +95,7 @@ class TestValidate(BaseTemplateTest):
         """
         path = self.DEFAULT_PATH
         validation = self.vitrage_client.template.validate(path=path)
-        self.assertNotEqual(len(validation), 0)
+        self.assertThat(validation, IsNotEmpty())
         for item in validation['results']:
             self._run_template_validation(item, path)
 
@@ -119,7 +122,7 @@ class TestValidate(BaseTemplateTest):
         try:
             path = self.TEST_PATH + self.ERROR_FILE
             validation = self.vitrage_client.template.validate(path=path)
-            self.assertEqual(1, len(validation['results']))
+            self.assertThat(validation['results'], matchers.HasLength(1))
             self._run_template_validation(
                 validation['results'][0], path, negative=True)
         except Exception:
@@ -133,7 +136,7 @@ class TestValidate(BaseTemplateTest):
         try:
             path = self.TEST_PATH + self.OK_FILE
             validation = self.vitrage_client.template.validate(path=path)
-            self.assertEqual(1, len(validation['results']))
+            self.assertThat(validation['results'], matchers.HasLength(1))
             self._run_template_validation(
                 validation['results'][0], path)
         except Exception:
@@ -148,7 +151,7 @@ class TestValidate(BaseTemplateTest):
         (in /etc/vitrage/templates folder)
         """
         template_list = self.vitrage_client.template.list()
-        self.assertNotEqual(len(template_list), 0)
+        self.assertThat(template_list, IsNotEmpty())
         for item in template_list:
             api_template_show = self.vitrage_client.template.show(item['uuid'])
             cli_template_show = utils.run_vitrage_command(
@@ -257,8 +260,8 @@ class TemplatesDBTest(BaseTemplateTest):
                 "vitrage template list", self.conf)
             api_templates_list = self.client.template.list()
 
-            self.assertNotEqual(len(api_templates_list), 0,
+            self.assertThat(api_templates_list, IsNotEmpty(),
-                                'The template list taken from api is empty')
+                            'The template list taken from api is empty')
             self.assertIsNotNone(cli_templates_list,
                                  'The template list taken from cli is empty')
             self._validate_templates_list_length(api_templates_list,

vitrage_tempest_plugin/tests/api/templates/test_template_v2.py

@@ -13,6 +13,7 @@
 # under the License.
 
 from oslo_log import log as logging
+from testtools import matchers
 
 from vitrage_tempest_plugin.tests.api.templates.base import BaseTemplateTest
 
@@ -37,7 +38,7 @@ class TestValidateV2(BaseTemplateTest):
         try:
             path = self.TEST_PATH + NO_TYPE_TEMPLATE
             validation = self.vitrage_client.template.validate(path=path)
-            self.assertEqual(1, len(validation['results']))
+            self.assertThat(validation['results'], matchers.HasLength(1))
             self._run_template_validation(
                 validation['results'][0], path, negative=True)
         except Exception:
@@ -47,7 +48,7 @@ class TestValidateV2(BaseTemplateTest):
         try:
             path = self.TEST_PATH + EXECUTE_MISTRAL_TEMPLATE
             validation = self.vitrage_client.template.validate(path=path)
-            self.assertEqual(1, len(validation['results']))
+            self.assertThat(validation['results'], matchers.HasLength(1))
             self._run_template_validation(
                 validation['results'][0], path)
         except Exception:
@@ -57,7 +58,7 @@ class TestValidateV2(BaseTemplateTest):
         try:
             path = self.TEST_PATH + DEFINITION_TEMPLATE
             validation = self.vitrage_client.template.validate(path=path)
-            self.assertEqual(1, len(validation['results']))
+            self.assertThat(validation['results'], matchers.HasLength(1))
             self._run_template_validation(
                 validation['results'][0], path)
         except Exception:

vitrage_tempest_plugin/tests/api/topology/base.py

@@ -18,6 +18,7 @@ import time
 
 from vitrage.common.constants import VertexProperties as VProps
 from vitrage_tempest_plugin.tests.base import BaseVitrageTempest
+from vitrage_tempest_plugin.tests.base import IsNotEmpty
 from vitrage_tempest_plugin.tests.base import LOG
 from vitrage_tempest_plugin.tests.common import cinder_utils
 from vitrage_tempest_plugin.tests.common import nova_utils
@@ -57,7 +58,8 @@ class BaseTopologyTest(BaseVitrageTempest):
     def _create_entities(self, num_instances, num_volumes=0, end_sleep=3):
         resources = nova_utils.create_instances(num_instances)
 
-        self.assertNotEqual(len(resources), 0, 'The instances list is empty')
+        self.assertThat(resources, IsNotEmpty(),
+                        'The instances list is empty')
         if num_volumes > 0:
             cinder_utils.create_volume_and_attach('volume-1', 1,
                                                   resources[0].id,
@@ -78,10 +80,10 @@ class BaseTopologyTest(BaseVitrageTempest):
 
     def _compare_graphs(self, api_graph, cli_graph):
         """Compare Graph object to graph form terminal """
-        self.assertNotEqual(len(api_graph), 0,
+        self.assertThat(api_graph, IsNotEmpty(),
-                            'The topology graph taken from rest api is empty')
+                        'The topology graph taken from rest api is empty')
-        self.assertNotEqual(len(cli_graph), 0,
+        self.assertThat(cli_graph, IsNotEmpty(),
-                            'The topology graph taken from terminal is empty')
+                        'The topology graph taken from terminal is empty')
 
         parsed_topology = json.loads(cli_graph)
 

vitrage_tempest_plugin/tests/api/topology/test_topology.py

@@ -17,6 +17,7 @@ from oslo_log import log as logging
 from vitrage.common.constants import VertexProperties as VProps
 from vitrage.datasources import OPENSTACK_CLUSTER
 from vitrage_tempest_plugin.tests.api.topology.base import BaseTopologyTest
+from vitrage_tempest_plugin.tests.base import IsEmpty
 import vitrage_tempest_plugin.tests.utils as utils
 from vitrageclient.exceptions import ClientException
 
@@ -382,12 +383,9 @@ class TestTopology(BaseTopologyTest):
                 query=self._graph_no_match_query(), all_tenants=True)
 
             # Test Assertions
-            self.assertEqual(
+            self.assertThat(api_graph['nodes'],
-                0,
+                            IsEmpty(), 'num of vertex node')
-                len(api_graph['nodes']), 'num of vertex node')
+            self.assertThat(api_graph['links'], IsEmpty(), 'num of edges')
-            self.assertEqual(
-                0,
-                len(api_graph['links']), 'num of edges')
         except Exception as e:
             self._handle_exception(e)
             raise

vitrage_tempest_plugin/tests/api/webhook/test_webhook.py

@@ -13,6 +13,7 @@
 #    under the License.
 
 from oslo_log import log as logging
+from testtools import matchers
 
 from vitrage_tempest_plugin.tests.base import BaseVitrageTempest
 from vitrage_tempest_plugin.tests.common.tempest_clients import TempestClients
@@ -39,10 +40,10 @@ class TestWebhook(BaseVitrageTempest):
     def test_add_webhook(self):
 
         webhooks = TempestClients.vitrage().webhook.list()
-        self.assertEqual(self.pre_test_webhook_count,
+        self.assertThat(webhooks,
-                         len(webhooks),
+                        matchers.HasLength(self.pre_test_webhook_count),
-                         'Amount of webhooks should be the same as '
+                        'Amount of webhooks should be '
-                         'before the test')
+                        'the same as before the test')
 
         created_webhook = TempestClients.vitrage().webhook.add(
             url="https://www.test.com",
@@ -64,16 +65,17 @@ class TestWebhook(BaseVitrageTempest):
 
         webhooks = TempestClients.vitrage().webhook.list()
 
-        self.assertEqual(self.pre_test_webhook_count + 1, len(webhooks))
+        self.assertThat(webhooks,
+                        matchers.HasLength(self.pre_test_webhook_count + 1))
         TempestClients.vitrage().webhook.delete(
             created_webhook['id'])
 
     def test_delete_webhook(self):
         webhooks = TempestClients.vitrage().webhook.list()
-        self.assertEqual(self.pre_test_webhook_count,
+        self.assertThat(webhooks,
-                         len(webhooks),
+                        matchers.HasLength(self.pre_test_webhook_count),
-                         'Amount of webhooks should be the same as '
+                        'Amount of webhooks should '
-                         'before the test')
+                        'be the same as before the test')
 
         created_webhook = TempestClients.vitrage().webhook.add(
             url="https://www.test.com",
@@ -85,8 +87,9 @@ class TestWebhook(BaseVitrageTempest):
             id=created_webhook['id'])
         self.assertIsNotNone(created_webhook.get('SUCCESS'),
                              'failed to delete')
-        self.assertEqual(self.pre_test_webhook_count, len(webhooks),
+        self.assertThat(webhooks,
-                         'No webhooks should exist after deletion')
+                        matchers.HasLength(self.pre_test_webhook_count),
+                        'No webhooks should exist after deletion')
 
     def test_delete_non_existing_webhook(self):
         self.assertRaises(ClientException,
@@ -96,10 +99,10 @@ class TestWebhook(BaseVitrageTempest):
     def test_list_webhook(self):
 
         webhooks = TempestClients.vitrage().webhook.list()
-        self.assertEqual(self.pre_test_webhook_count,
+        self.assertThat(webhooks,
-                         len(webhooks),
+                        matchers.HasLength(self.pre_test_webhook_count),
-                         'Amount of webhooks should be the same as '
+                        'Amount of webhooks should be '
-                         'before the test')
+                        'the same as before the test')
 
         created_webhook = TempestClients.vitrage().webhook.add(
             url="https://www.test.com",
@@ -108,7 +111,8 @@ class TestWebhook(BaseVitrageTempest):
         )
 
         webhooks = TempestClients.vitrage().webhook.list()
-        self.assertEqual(self.pre_test_webhook_count + 1, len(webhooks))
+        self.assertThat(webhooks,
+                        matchers.HasLength(self.pre_test_webhook_count + 1))
         self.assertEqual(created_webhook[HEADERS], webhooks[0][HEADERS])
         self.assertEqual(created_webhook['id'], webhooks[0]['id'])
         self.assertEqual(created_webhook[REGEX_FILTER],
@@ -119,10 +123,10 @@ class TestWebhook(BaseVitrageTempest):
 
     def test_show_webhook(self):
         webhooks = TempestClients.vitrage().webhook.list()
-        self.assertEqual(self.pre_test_webhook_count,
+        self.assertThat(webhooks,
-                         len(webhooks),
+                        matchers.HasLength(self.pre_test_webhook_count),
-                         'Amount of webhooks should be the same as '
+                        'Amount of webhooks should be '
-                         'before the test')
+                        'the same as before the test')
 
         created_webhook = TempestClients.vitrage().webhook.add(
             url="https://www.test.com",

vitrage_tempest_plugin/tests/base.py

@@ -20,6 +20,7 @@ from oslo_log import log as logging
 from oslo_utils import timeutils
 from oslotest import base
 from testtools.matchers import HasLength
+from testtools.matchers import Not
 
 from vitrage.common.constants import EdgeProperties
 from vitrage.common.constants import EntityCategory
@@ -46,6 +47,7 @@ import warnings
 LOG = logging.getLogger(__name__)
 
 IsEmpty = lambda: HasLength(0)
+IsNotEmpty = lambda: Not(IsEmpty())
 
 if six.PY2:
     class ResourceWarning(Warning):

vitrage_tempest_plugin/tests/e2e/test_actions_base.py

@@ -14,6 +14,7 @@
 import time
 
 from oslo_log import log as logging
+from testtools import matchers
 
 from vitrage.common.constants import VertexProperties as VProps
 from vitrage_tempest_plugin.tests.base import BaseVitrageTempest
@@ -62,11 +63,9 @@ class TestActionsBase(BaseVitrageTempest):
             vitrage_id=resource_id,
             all_tenants=True)
         deduces = g_utils.all_matches(alarms, **deduced_props)
-        self.assertEqual(
+        self.assertThat(deduces, matchers.HasLength(deduced_count),
-            deduced_count,
+                        'Expected %s deduces\n - \n%s\n - \n%s' %
-            len(deduces),
+                        (str(deduced_count), str(alarms), str(deduces)))
-            'Expected %s deduces\n - \n%s\n - \n%s' %
-            (str(deduced_count), str(alarms), str(deduces)))
 
     def _check_rca(self, rca, expected_alarms, inspected):
         self.assertEqual(len(expected_alarms), len(rca['nodes']))

vitrage_tempest_plugin/tests/e2e/test_overlapping_actions.py

@@ -20,6 +20,7 @@ from vitrage.common.constants import VertexProperties as VProps
 from vitrage.datasources.doctor import DOCTOR_DATASOURCE
 from vitrage.evaluator.actions.evaluator_event_transformer import \
     VITRAGE_DATASOURCE
+from vitrage_tempest_plugin.tests.base import IsEmpty
 from vitrage_tempest_plugin.tests.common import general_utils as g_utils
 from vitrage_tempest_plugin.tests.common.tempest_clients import TempestClients
 from vitrage_tempest_plugin.tests.common import vitrage_utils as v_utils
@@ -231,17 +232,17 @@ class TestOverlappingActions(TestActionsBase):
             alarms = TempestClients.vitrage().alarm.list(
                 vitrage_id=self.orig_host.get(VProps.VITRAGE_ID),
                 all_tenants=True)
-            self.assertEqual(
+            self.assertThat(
-                0,
+                g_utils.all_matches(alarms, **TRIGGER_ALARM_1_PROPS),
-                len(g_utils.all_matches(alarms, **TRIGGER_ALARM_1_PROPS)),
+                IsEmpty(),
                 'trigger alarm 1 should have been removed')
-            self.assertEqual(
+            self.assertThat(
-                0,
+                g_utils.all_matches(alarms, **TRIGGER_ALARM_2_PROPS),
-                len(g_utils.all_matches(alarms, **TRIGGER_ALARM_2_PROPS)),
+                IsEmpty(),
                 'trigger alarm 2 should have been removed')
-            self.assertEqual(
+            self.assertThat(
-                0,
+                g_utils.all_matches(alarms, **DEDUCED_PROPS),
-                len(g_utils.all_matches(alarms, **DEDUCED_PROPS)),
+                IsEmpty(),
                 'deduced alarm should have been removed')
 
         except Exception as e: