openstack/vitrage
Code Issues Proposed changes

Fixed order of arguments in assertEqual

Browse Source 
Some tests used incorrect order of arguments in
assertEqual(observed, expected). The correct order expected
by testtool is assertEqual(expected, observed).

Change-Id: I4962812206ea170c855a2574083b7b136d067850
This commit is contained in:
sudhir_agarwal 2017-07-17 16:57:01 +05:30
parent e405beae70
commit 6491f4c078
23 changed files with 304 additions and 325 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

413
vitrage/tests/functional/evaluator/test_scenario_evaluator.py
View File

@ -456,12 +456,12 @@ class TestScenarioEvaluator(TestFunctionalBase):
self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges, self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges,
entity_graph.num_edges()) entity_graph.num_edges())
self.assertEqual(1, len(port_neighbors)) self.assertEqual(1, len(port_neighbors))
self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) port_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) port_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(port_neighbors[0][VProps.NAME], self.assertEqual('simple_port_deduced_alarm',
'simple_port_deduced_alarm') port_neighbors[0][VProps.NAME])
# Add PORT_PROBLEM alarm # Add PORT_PROBLEM alarm
test_vals = {'status': NagiosTestStatus.WARNING, test_vals = {'status': NagiosTestStatus.WARNING,
@ -491,26 +491,25 @@ class TestScenarioEvaluator(TestFunctionalBase):
port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, port_neighbors = entity_graph.neighbors(port_vertex.vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(port_neighbors)) self.assertEqual(1, len(port_neighbors))
self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) port_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) port_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(port_neighbors[0][VProps.NAME], self.assertEqual('simple_port_deduced_alarm',
'simple_port_deduced_alarm') port_neighbors[0][VProps.NAME])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], True) self.assertTrue(port_neighbors[0][VProps.VITRAGE_IS_DELETED])
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE}
port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, port_neighbors = entity_graph.neighbors(port_vertex.vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) port_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(NAGIOS_DATASOURCE,
NAGIOS_DATASOURCE) port_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(port_neighbors[0][VProps.NAME], 'PORT_PROBLEM') self.assertEqual('PORT_PROBLEM', port_neighbors[0][VProps.NAME])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], False) self.assertFalse(port_neighbors[0][VProps.VITRAGE_IS_DELETED])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], self.assertFalse(port_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
False)
# ################### STEP 3 ################### # ################### STEP 3 ###################
# disable connection between port and alarm # disable connection between port and alarm
@ -544,14 +543,14 @@ class TestScenarioEvaluator(TestFunctionalBase):
port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, port_neighbors = entity_graph.neighbors(port_vertex.vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(port_neighbors)) self.assertEqual(1, len(port_neighbors))
self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) port_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) port_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(port_neighbors[0][VProps.NAME], self.assertEqual('simple_port_deduced_alarm',
'simple_port_deduced_alarm') port_neighbors[0][VProps.NAME])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], self.assertEqual(vitrage_is_deleted,
vitrage_is_deleted) port_neighbors[0][VProps.VITRAGE_IS_DELETED])
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE,
VProps.VITRAGE_IS_DELETED: False} VProps.VITRAGE_IS_DELETED: False}
@ -561,12 +560,12 @@ class TestScenarioEvaluator(TestFunctionalBase):
VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE}
port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, port_neighbors = entity_graph.neighbors(port_vertex.vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) port_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(NAGIOS_DATASOURCE,
NAGIOS_DATASOURCE) port_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(port_neighbors[0][VProps.NAME], 'PORT_PROBLEM') self.assertEqual('PORT_PROBLEM', port_neighbors[0][VProps.NAME])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], False) self.assertFalse(port_neighbors[0][VProps.VITRAGE_IS_DELETED])
# ################### STEP 4 ################### # ################### STEP 4 ###################
# enable connection between port and alarm # enable connection between port and alarm
@ -602,15 +601,16 @@ class TestScenarioEvaluator(TestFunctionalBase):
self.assertEqual(2, len(port_neighbors)) self.assertEqual(2, len(port_neighbors))
for in_counter in range(0, 1): for in_counter in range(0, 1):
self.assertEqual( self.assertEqual(
port_neighbors[in_counter][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM,
EntityCategory.ALARM) port_neighbors[in_counter][VProps.VITRAGE_CATEGORY])
self.assertEqual(port_neighbors[in_counter] self.assertEqual(VITRAGE_DATASOURCE,
[VProps.VITRAGE_TYPE], VITRAGE_DATASOURCE) port_neighbors[in_counter]
self.assertEqual(port_neighbors[in_counter][VProps.NAME], [VProps.VITRAGE_TYPE])
'simple_port_deduced_alarm') self.assertEqual('simple_port_deduced_alarm',
port_neighbors[in_counter][VProps.NAME])
self.assertEqual( self.assertEqual(
port_neighbors[in_counter][VProps.VITRAGE_IS_DELETED], vitrage_is_deleted,
vitrage_is_deleted) port_neighbors[in_counter][VProps.VITRAGE_IS_DELETED])
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE,
@ -621,12 +621,12 @@ class TestScenarioEvaluator(TestFunctionalBase):
VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE}
port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, port_neighbors = entity_graph.neighbors(port_vertex.vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) port_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(NAGIOS_DATASOURCE,
NAGIOS_DATASOURCE) port_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(port_neighbors[0][VProps.NAME], 'PORT_PROBLEM') self.assertEqual('PORT_PROBLEM', port_neighbors[0][VProps.NAME])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], False) self.assertFalse(port_neighbors[0][VProps.VITRAGE_IS_DELETED])
# ################### STEP 5 ################### # ################### STEP 5 ###################
# disable PORT_PROBLEM alarm # disable PORT_PROBLEM alarm
@ -658,15 +658,15 @@ class TestScenarioEvaluator(TestFunctionalBase):
self.assertEqual(2, len(port_neighbors)) self.assertEqual(2, len(port_neighbors))
for in_counter in range(0, 1): for in_counter in range(0, 1):
self.assertEqual( self.assertEqual(
port_neighbors[in_counter][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM,
EntityCategory.ALARM) port_neighbors[in_counter][VProps.VITRAGE_CATEGORY])
self.assertEqual(port_neighbors[in_counter] self.assertEqual(VITRAGE_DATASOURCE, port_neighbors[in_counter]
[VProps.VITRAGE_TYPE], VITRAGE_DATASOURCE) [VProps.VITRAGE_TYPE])
self.assertEqual(port_neighbors[in_counter][VProps.NAME], self.assertEqual('simple_port_deduced_alarm',
'simple_port_deduced_alarm') port_neighbors[in_counter][VProps.NAME])
self.assertEqual( self.assertEqual(
port_neighbors[in_counter][VProps.VITRAGE_IS_DELETED], vitrage_is_deleted,
vitrage_is_deleted) port_neighbors[in_counter][VProps.VITRAGE_IS_DELETED])
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE,
@ -677,12 +677,12 @@ class TestScenarioEvaluator(TestFunctionalBase):
VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE}
port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, port_neighbors = entity_graph.neighbors(port_vertex.vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) port_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(NAGIOS_DATASOURCE,
NAGIOS_DATASOURCE) port_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(port_neighbors[0][VProps.NAME], 'PORT_PROBLEM') self.assertEqual('PORT_PROBLEM', port_neighbors[0][VProps.NAME])
self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], True) self.assertTrue(port_neighbors[0][VProps.VITRAGE_IS_DELETED])
def test_complex_not_operator_deduced_alarm(self): def test_complex_not_operator_deduced_alarm(self):
"""Handles a complex not operator use case """Handles a complex not operator use case
@ -763,12 +763,12 @@ class TestScenarioEvaluator(TestFunctionalBase):
self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges, self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges,
entity_graph.num_edges()) entity_graph.num_edges())
self.assertEqual(1, len(zone_neighbors)) self.assertEqual(1, len(zone_neighbors))
self.assertEqual(zone_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) zone_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(zone_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) zone_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(zone_neighbors[0][VProps.NAME], self.assertEqual('complex_zone_deduced_alarm',
'complex_zone_deduced_alarm') zone_neighbors[0][VProps.NAME])
# ################### STEP 2 ################### # ################### STEP 2 ###################
# Add NETWORK_PROBLEM alarm # Add NETWORK_PROBLEM alarm
@ -797,26 +797,24 @@ class TestScenarioEvaluator(TestFunctionalBase):
network_neighbors = entity_graph.neighbors(network_vertex.vertex_id, network_neighbors = entity_graph.neighbors(network_vertex.vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(network_neighbors)) self.assertEqual(1, len(network_neighbors))
self.assertEqual(network_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) network_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(network_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(NAGIOS_DATASOURCE,
NAGIOS_DATASOURCE) network_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(network_neighbors[0][VProps.NAME], 'NETWORK_PROBLEM') self.assertEqual('NETWORK_PROBLEM', network_neighbors[0][VProps.NAME])
self.assertEqual(network_neighbors[0][VProps.VITRAGE_IS_DELETED], self.assertFalse(network_neighbors[0][VProps.VITRAGE_IS_DELETED])
False) self.assertFalse(network_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
self.assertEqual(network_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER],
False)
zone_neighbors = entity_graph.neighbors(zone_vertex.vertex_id, zone_neighbors = entity_graph.neighbors(zone_vertex.vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(zone_neighbors)) self.assertEqual(1, len(zone_neighbors))
self.assertEqual(zone_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) zone_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(zone_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) zone_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(zone_neighbors[0][VProps.NAME], self.assertEqual('complex_zone_deduced_alarm',
'complex_zone_deduced_alarm') zone_neighbors[0][VProps.NAME])
self.assertEqual(zone_neighbors[0][VProps.VITRAGE_IS_DELETED], True) self.assertTrue(zone_neighbors[0][VProps.VITRAGE_IS_DELETED])
# ################### STEP 3 ################### # ################### STEP 3 ###################
# delete NETWORK_PROBLEM alarm # delete NETWORK_PROBLEM alarm
@ -839,12 +837,12 @@ class TestScenarioEvaluator(TestFunctionalBase):
network_neighbors = entity_graph.neighbors(network_vertex.vertex_id, network_neighbors = entity_graph.neighbors(network_vertex.vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(network_neighbors)) self.assertEqual(1, len(network_neighbors))
self.assertEqual(network_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) network_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(network_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(NAGIOS_DATASOURCE,
NAGIOS_DATASOURCE) network_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(network_neighbors[0][VProps.NAME], 'NETWORK_PROBLEM') self.assertEqual('NETWORK_PROBLEM', network_neighbors[0][VProps.NAME])
self.assertEqual(network_neighbors[0][VProps.VITRAGE_IS_DELETED], True) self.assertTrue(network_neighbors[0][VProps.VITRAGE_IS_DELETED])
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_IS_DELETED: True} VProps.VITRAGE_IS_DELETED: True}
@ -855,14 +853,14 @@ class TestScenarioEvaluator(TestFunctionalBase):
zone_neighbors = entity_graph.neighbors(zone_vertex.vertex_id, zone_neighbors = entity_graph.neighbors(zone_vertex.vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(zone_neighbors)) self.assertEqual(1, len(zone_neighbors))
self.assertEqual(zone_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) zone_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(zone_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) zone_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(zone_neighbors[0][VProps.NAME], self.assertEqual('complex_zone_deduced_alarm',
'complex_zone_deduced_alarm') zone_neighbors[0][VProps.NAME])
self.assertEqual(zone_neighbors[0][VProps.VITRAGE_IS_DELETED], self.assertEqual(vitrage_is_deleted,
vitrage_is_deleted) zone_neighbors[0][VProps.VITRAGE_IS_DELETED])
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_IS_DELETED: False} VProps.VITRAGE_IS_DELETED: False}
@ -920,29 +918,26 @@ class TestScenarioEvaluator(TestFunctionalBase):
instance_neighbors = entity_graph.neighbors(instances[0].vertex_id, instance_neighbors = entity_graph.neighbors(instances[0].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(instance_neighbors)) self.assertEqual(1, len(instance_neighbors))
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.RESOURCE,
EntityCategory.RESOURCE) instance_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(CINDER_VOLUME_DATASOURCE,
CINDER_VOLUME_DATASOURCE) instance_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(instance_neighbors[0][VProps.NAME], 'volume-1') self.assertEqual('volume-1', instance_neighbors[0][VProps.NAME])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_DELETED], self.assertFalse(instance_neighbors[0][VProps.VITRAGE_IS_DELETED])
False) self.assertFalse(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER],
False)
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE} VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE}
host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, host_neighbors = entity_graph.neighbors(hosts[0].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) host_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) host_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(host_neighbors[0][VProps.NAME], self.assertEqual('ha_warning_deduced_alarm',
'ha_warning_deduced_alarm') host_neighbors[0][VProps.NAME])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], False) self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_DELETED])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
False)
# ################### STEP 2 ################### # ################### STEP 2 ###################
# Add cinder volume 2 # Add cinder volume 2
@ -972,15 +967,13 @@ class TestScenarioEvaluator(TestFunctionalBase):
instance_neighbors = entity_graph.neighbors(instances[1].vertex_id, instance_neighbors = entity_graph.neighbors(instances[1].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(instance_neighbors)) self.assertEqual(1, len(instance_neighbors))
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.RESOURCE,
EntityCategory.RESOURCE) instance_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(CINDER_VOLUME_DATASOURCE,
CINDER_VOLUME_DATASOURCE) instance_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(instance_neighbors[0][VProps.NAME], 'volume-2') self.assertEqual('volume-2', instance_neighbors[0][VProps.NAME])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_DELETED], self.assertFalse(instance_neighbors[0][VProps.VITRAGE_IS_DELETED])
False) self.assertFalse(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER],
False)
# check ha_error_deduced_alarm # check ha_error_deduced_alarm
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
@ -989,15 +982,14 @@ class TestScenarioEvaluator(TestFunctionalBase):
host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, host_neighbors = entity_graph.neighbors(hosts[0].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(host_neighbors)) self.assertEqual(1, len(host_neighbors))
self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) host_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) host_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(host_neighbors[0][VProps.NAME], self.assertEqual('ha_error_deduced_alarm',
'ha_error_deduced_alarm') host_neighbors[0][VProps.NAME])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], False) self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_DELETED])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
False)
# check ha_warning_deduced_alarm # check ha_warning_deduced_alarm
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
@ -1006,15 +998,14 @@ class TestScenarioEvaluator(TestFunctionalBase):
host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, host_neighbors = entity_graph.neighbors(hosts[0].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(host_neighbors)) self.assertEqual(1, len(host_neighbors))
self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) host_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) host_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(host_neighbors[0][VProps.NAME], self.assertEqual('ha_warning_deduced_alarm',
'ha_warning_deduced_alarm') host_neighbors[0][VProps.NAME])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], True) self.assertTrue(host_neighbors[0][VProps.VITRAGE_IS_DELETED])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
False)
# ################### STEP 3 ################### # ################### STEP 3 ###################
# Remove Cinder Volume 2 # Remove Cinder Volume 2
@ -1043,15 +1034,13 @@ class TestScenarioEvaluator(TestFunctionalBase):
instance_neighbors = entity_graph.neighbors(instances[1].vertex_id, instance_neighbors = entity_graph.neighbors(instances[1].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(instance_neighbors)) self.assertEqual(1, len(instance_neighbors))
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.RESOURCE,
EntityCategory.RESOURCE) instance_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(CINDER_VOLUME_DATASOURCE,
CINDER_VOLUME_DATASOURCE) instance_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(instance_neighbors[0][VProps.NAME], 'volume-2') self.assertEqual('volume-2', instance_neighbors[0][VProps.NAME])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_DELETED], self.assertFalse(instance_neighbors[0][VProps.VITRAGE_IS_DELETED])
False) self.assertFalse(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER],
False)
# check ha_error_deduced_alarm # check ha_error_deduced_alarm
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
@ -1060,15 +1049,14 @@ class TestScenarioEvaluator(TestFunctionalBase):
host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, host_neighbors = entity_graph.neighbors(hosts[0].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(host_neighbors)) self.assertEqual(1, len(host_neighbors))
self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) host_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) host_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(host_neighbors[0][VProps.NAME], self.assertEqual('ha_error_deduced_alarm',
'ha_error_deduced_alarm') host_neighbors[0][VProps.NAME])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], True) self.assertTrue(host_neighbors[0][VProps.VITRAGE_IS_DELETED])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
False)
# check new ha_warning_deduced_alarm # check new ha_warning_deduced_alarm
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
@ -1078,15 +1066,14 @@ class TestScenarioEvaluator(TestFunctionalBase):
host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, host_neighbors = entity_graph.neighbors(hosts[0].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(host_neighbors)) self.assertEqual(1, len(host_neighbors))
self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) host_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) host_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(host_neighbors[0][VProps.NAME], self.assertEqual('ha_warning_deduced_alarm',
'ha_warning_deduced_alarm') host_neighbors[0][VProps.NAME])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], False) self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_DELETED])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
False)
# check old deleted ha_warning_deduced_alarm # check old deleted ha_warning_deduced_alarm
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
@ -1096,15 +1083,14 @@ class TestScenarioEvaluator(TestFunctionalBase):
host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, host_neighbors = entity_graph.neighbors(hosts[0].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(host_neighbors)) self.assertEqual(1, len(host_neighbors))
self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) host_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) host_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(host_neighbors[0][VProps.NAME], self.assertEqual('ha_warning_deduced_alarm',
'ha_warning_deduced_alarm') host_neighbors[0][VProps.NAME])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], True) self.assertTrue(host_neighbors[0][VProps.VITRAGE_IS_DELETED])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
False)
# ################### STEP 4 ################### # ################### STEP 4 ###################
# Remove Cinder Volume 1 # Remove Cinder Volume 1
@ -1133,15 +1119,13 @@ class TestScenarioEvaluator(TestFunctionalBase):
instance_neighbors = entity_graph.neighbors(instances[0].vertex_id, instance_neighbors = entity_graph.neighbors(instances[0].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(instance_neighbors)) self.assertEqual(1, len(instance_neighbors))
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.RESOURCE,
EntityCategory.RESOURCE) instance_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(CINDER_VOLUME_DATASOURCE,
CINDER_VOLUME_DATASOURCE) instance_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(instance_neighbors[0][VProps.NAME], 'volume-1') self.assertEqual('volume-1', instance_neighbors[0][VProps.NAME])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_DELETED], self.assertFalse(instance_neighbors[0][VProps.VITRAGE_IS_DELETED])
False) self.assertFalse(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER],
False)
# check ha_error_deduced_alarm # check ha_error_deduced_alarm
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
@ -1150,15 +1134,14 @@ class TestScenarioEvaluator(TestFunctionalBase):
host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, host_neighbors = entity_graph.neighbors(hosts[0].vertex_id,
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(1, len(host_neighbors)) self.assertEqual(1, len(host_neighbors))
self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) host_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) host_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(host_neighbors[0][VProps.NAME], self.assertEqual('ha_error_deduced_alarm',
'ha_error_deduced_alarm') host_neighbors[0][VProps.NAME])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], True) self.assertTrue(host_neighbors[0][VProps.VITRAGE_IS_DELETED])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
False)
# check old ha_warning_deduced_alarm # check old ha_warning_deduced_alarm
query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
@ -1168,25 +1151,23 @@ class TestScenarioEvaluator(TestFunctionalBase):
vertex_attr_filter=query) vertex_attr_filter=query)
self.assertEqual(2, len(host_neighbors)) self.assertEqual(2, len(host_neighbors))
self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) host_neighbors[0][VProps.VITRAGE_CATEGORY])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) host_neighbors[0][VProps.VITRAGE_TYPE])
self.assertEqual(host_neighbors[0][VProps.NAME], self.assertEqual('ha_warning_deduced_alarm',
'ha_warning_deduced_alarm') host_neighbors[0][VProps.NAME])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], True) self.assertTrue(host_neighbors[0][VProps.VITRAGE_IS_DELETED])
self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], self.assertFalse(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER])
False)
self.assertEqual(host_neighbors[1][VProps.VITRAGE_CATEGORY], self.assertEqual(EntityCategory.ALARM,
EntityCategory.ALARM) host_neighbors[1][VProps.VITRAGE_CATEGORY])
self.assertEqual(host_neighbors[1][VProps.VITRAGE_TYPE], self.assertEqual(VITRAGE_DATASOURCE,
VITRAGE_DATASOURCE) host_neighbors[1][VProps.VITRAGE_TYPE])
self.assertEqual(host_neighbors[1][VProps.NAME], self.assertEqual('ha_warning_deduced_alarm',
'ha_warning_deduced_alarm') host_neighbors[1][VProps.NAME])
self.assertEqual(host_neighbors[1][VProps.VITRAGE_IS_DELETED], True) self.assertTrue(host_neighbors[1][VProps.VITRAGE_IS_DELETED])
self.assertEqual(host_neighbors[1][VProps.VITRAGE_IS_PLACEHOLDER], self.assertFalse(host_neighbors[1][VProps.VITRAGE_IS_PLACEHOLDER])
False)
def test_simple_or_operator_deduced_alarm(self): def test_simple_or_operator_deduced_alarm(self):
"""Handles a simple not operator use case """Handles a simple not operator use case

5
vitrage/tests/unit/datasources/aodh/test_aodh_driver.py
View File

@ -118,7 +118,7 @@ class AodhDriverTest(base.BaseTest):
self.assertEqual(entity[AodhProps.SEVERITY], self.assertEqual(entity[AodhProps.SEVERITY],
alarm[AodhProps.SEVERITY]) alarm[AodhProps.SEVERITY])
self.assertIsNone(entity[AodhProps.RESOURCE_ID]) self.assertIsNone(entity[AodhProps.RESOURCE_ID])
self.assertEqual(entity[AodhProps.EVENT_TYPE], "*") self.assertEqual("*", entity[AodhProps.EVENT_TYPE])
self.assertEqual(entity[DSProps.EVENT_TYPE], self.assertEqual(entity[DSProps.EVENT_TYPE],
AodhEventType.CREATION) AodhEventType.CREATION)
@ -148,8 +148,7 @@ class AodhDriverTest(base.BaseTest):
self.assertEqual( self.assertEqual(
entity[AodhProps.EVENT_TYPE], entity[AodhProps.EVENT_TYPE],
alarm[AodhProps.DETAIL][AodhProps.RULE][AodhProps.EVENT_TYPE]) alarm[AodhProps.DETAIL][AodhProps.RULE][AodhProps.EVENT_TYPE])
self.assertEqual(entity[AodhProps.RESOURCE_ID], self.assertEqual("1", entity[AodhProps.RESOURCE_ID])
"1")
self.assertEqual(entity[DSProps.EVENT_TYPE], self.assertEqual(entity[DSProps.EVENT_TYPE],
AodhEventType.RULE_CHANGE) AodhEventType.RULE_CHANGE)

12
vitrage/tests/unit/datasources/cinder/test_cinder_volume_transformer.py
View File

@ -80,22 +80,22 @@ class TestCinderVolumeTransformer(base.BaseTest):
TransformerBase.KEY_SEPARATOR) TransformerBase.KEY_SEPARATOR)
expected_id_values = transformer._key_values(CINDER_VOLUME_DATASOURCE, expected_id_values = transformer._key_values(CINDER_VOLUME_DATASOURCE,
volume_id) volume_id)
self.assertEqual(tuple(observed_id_values), expected_id_values) self.assertEqual(expected_id_values, tuple(observed_id_values))
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(observed_time, timestamp) self.assertEqual(timestamp, observed_time)
observed_type = placeholder.get(VProps.VITRAGE_TYPE) observed_type = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(observed_type, CINDER_VOLUME_DATASOURCE) self.assertEqual(CINDER_VOLUME_DATASOURCE, observed_type)
observed_entity_id = placeholder.get(VProps.ID) observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(observed_entity_id, volume_id) self.assertEqual(volume_id, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertEqual(vitrage_is_placeholder, True) self.assertTrue(vitrage_is_placeholder)
def test_key_values(self): def test_key_values(self):
LOG.debug('Cinder Volume transformer test: get key values') LOG.debug('Cinder Volume transformer test: get key values')

12
vitrage/tests/unit/datasources/heat/test_heat_stack_transformer.py
View File

@ -81,22 +81,22 @@ class TestHeatStackTransformer(base.BaseTest):
TransformerBase.KEY_SEPARATOR) TransformerBase.KEY_SEPARATOR)
expected_id_values = transformer._key_values(HEAT_STACK_DATASOURCE, expected_id_values = transformer._key_values(HEAT_STACK_DATASOURCE,
stack_id) stack_id)
self.assertEqual(tuple(observed_id_values), expected_id_values) self.assertEqual(expected_id_values, tuple(observed_id_values))
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(observed_time, timestamp) self.assertEqual(timestamp, observed_time)
observed_type = placeholder.get(VProps.VITRAGE_TYPE) observed_type = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(observed_type, HEAT_STACK_DATASOURCE) self.assertEqual(HEAT_STACK_DATASOURCE, observed_type)
observed_entity_id = placeholder.get(VProps.ID) observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(observed_entity_id, stack_id) self.assertEqual(stack_id, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertEqual(vitrage_is_placeholder, True) self.assertTrue(vitrage_is_placeholder)
def test_key_values(self): def test_key_values(self):
LOG.debug('Heat Stack transformer test: get key values') LOG.debug('Heat Stack transformer test: get key values')

12
vitrage/tests/unit/datasources/nova/test_nova_host_transformer.py
View File

@ -80,22 +80,22 @@ class NovaHostTransformerTest(base.BaseTest):
expected_id_values = host_transformer._key_values( expected_id_values = host_transformer._key_values(
NOVA_HOST_DATASOURCE, NOVA_HOST_DATASOURCE,
host_name) host_name)
self.assertEqual(tuple(observed_id_values), expected_id_values) self.assertEqual(expected_id_values, tuple(observed_id_values))
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(observed_time, timestamp) self.assertEqual(timestamp, observed_time)
observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) observed_subtype = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(observed_subtype, NOVA_HOST_DATASOURCE) self.assertEqual(NOVA_HOST_DATASOURCE, observed_subtype)
observed_entity_id = placeholder.get(VProps.ID) observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(observed_entity_id, host_name) self.assertEqual(host_name, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertEqual(vitrage_is_placeholder, True) self.assertTrue(vitrage_is_placeholder)
def test_key_values(self): def test_key_values(self):

12
vitrage/tests/unit/datasources/nova/test_nova_instance_transformer.py
View File

@ -79,22 +79,22 @@ class NovaInstanceTransformerTest(base.BaseTest):
TransformerBase.KEY_SEPARATOR) TransformerBase.KEY_SEPARATOR)
expected_id_values = transformer._key_values(NOVA_INSTANCE_DATASOURCE, expected_id_values = transformer._key_values(NOVA_INSTANCE_DATASOURCE,
instance_id) instance_id)
self.assertEqual(tuple(observed_id_values), expected_id_values) self.assertEqual(expected_id_values, tuple(observed_id_values))
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(observed_time, timestamp) self.assertEqual(timestamp, observed_time)
observed_type = placeholder.get(VProps.VITRAGE_TYPE) observed_type = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(observed_type, NOVA_INSTANCE_DATASOURCE) self.assertEqual(NOVA_INSTANCE_DATASOURCE, observed_type)
observed_entity_id = placeholder.get(VProps.ID) observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(observed_entity_id, instance_id) self.assertEqual(instance_id, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertEqual(vitrage_is_placeholder, True) self.assertTrue(vitrage_is_placeholder)
def test_snapshot_event_transform(self): def test_snapshot_event_transform(self):
LOG.debug('Test tactual transform action for ' LOG.debug('Test tactual transform action for '

17
vitrage/tests/unit/datasources/nova/test_nova_zone_transformer.py
View File

@ -80,22 +80,22 @@ class NovaZoneTransformerTest(base.BaseTest):
TransformerBase.KEY_SEPARATOR) TransformerBase.KEY_SEPARATOR)
expected_id_values = self.transformers[NOVA_ZONE_DATASOURCE].\ expected_id_values = self.transformers[NOVA_ZONE_DATASOURCE].\
_key_values(NOVA_ZONE_DATASOURCE, zone_name) _key_values(NOVA_ZONE_DATASOURCE, zone_name)
self.assertEqual(tuple(observed_id_values), expected_id_values) self.assertEqual(expected_id_values, tuple(observed_id_values))
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(observed_time, timestamp) self.assertEqual(timestamp, observed_time)
observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) observed_subtype = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(observed_subtype, NOVA_ZONE_DATASOURCE) self.assertEqual(NOVA_ZONE_DATASOURCE, observed_subtype)
observed_entity_id = placeholder.get(VProps.ID) observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(observed_entity_id, zone_name) self.assertEqual(zone_name, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertEqual(vitrage_is_placeholder, True) self.assertTrue(vitrage_is_placeholder)
def test_key_values(self): def test_key_values(self):
LOG.debug('Zone transformer test: get key values') LOG.debug('Zone transformer test: get key values')
@ -208,13 +208,12 @@ class NovaZoneTransformerTest(base.BaseTest):
self.assertEqual(cluster_neighbor.vertex[VProps.VITRAGE_ID], self.assertEqual(cluster_neighbor.vertex[VProps.VITRAGE_ID],
cluster_neighbor.vertex.vertex_id) cluster_neighbor.vertex.vertex_id)
self.assertEqual(False, self.assertFalse(cluster_neighbor.vertex[VProps.VITRAGE_IS_DELETED])
cluster_neighbor.vertex[VProps.VITRAGE_IS_DELETED])
self.assertEqual(EntityCategory.RESOURCE, self.assertEqual(EntityCategory.RESOURCE,
cluster_neighbor.vertex[VProps.VITRAGE_CATEGORY]) cluster_neighbor.vertex[VProps.VITRAGE_CATEGORY])
self.assertEqual(CLUSTER_ID, self.assertEqual(CLUSTER_ID,
cluster_neighbor.vertex[VProps.ID]) cluster_neighbor.vertex[VProps.ID])
self.assertEqual(False, cluster_neighbor.vertex[ self.assertFalse(cluster_neighbor.vertex[
VProps.VITRAGE_IS_PLACEHOLDER]) VProps.VITRAGE_IS_PLACEHOLDER])
self.assertEqual(OPENSTACK_CLUSTER, self.assertEqual(OPENSTACK_CLUSTER,
cluster_neighbor.vertex[VProps.VITRAGE_TYPE]) cluster_neighbor.vertex[VProps.VITRAGE_TYPE])

14
vitrage/tests/unit/datasources/static/test_static_transformer.py
View File

@ -67,22 +67,22 @@ class TestStaticTransformer(base.BaseTest):
observed_entity_id = placeholder.vertex_id observed_entity_id = placeholder.vertex_id
expected_entity_id = 'RESOURCE:static:12345' expected_entity_id = 'RESOURCE:static:12345'
self.assertEqual(observed_entity_id, expected_entity_id) self.assertEqual(expected_entity_id, observed_entity_id)
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(observed_time, self.timestamp) self.assertEqual(self.timestamp, observed_time)
observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) observed_subtype = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(observed_subtype, self.entity_type) self.assertEqual(self.entity_type, observed_subtype)
observed_entity_id = placeholder.get(VProps.ID) observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(observed_entity_id, self.entity_id) self.assertEqual(self.entity_id, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertEqual(vitrage_is_placeholder, True) self.assertTrue(vitrage_is_placeholder)
def test_snapshot_transform(self): def test_snapshot_transform(self):
vals_list = mock_driver.simple_static_generators(snapshot_events=1) vals_list = mock_driver.simple_static_generators(snapshot_events=1)
@ -110,7 +110,7 @@ class TestStaticTransformer(base.BaseTest):
event[DSProps.SAMPLE_DATE]) event[DSProps.SAMPLE_DATE])
for k, v in event.get(StaticFields.METADATA, {}): for k, v in event.get(StaticFields.METADATA, {}):
self.assertEqual(vertex[k], v) self.assertEqual(v, vertex[k])
def _validate_common_props(self, vertex, event): def _validate_common_props(self, vertex, event):
self.assertEqual(vertex[VProps.VITRAGE_CATEGORY], self.assertEqual(vertex[VProps.VITRAGE_CATEGORY],

10
vitrage/tests/unit/datasources/static_physical/test_static_physical_driver.py
View File

@ -113,24 +113,24 @@ class TestStaticPhysicalDriver(base.BaseTest):
# Test Assertions # Test Assertions
status = any(change[StaticFields.TYPE] == SWITCH and status = any(change[StaticFields.TYPE] == SWITCH and
change[StaticFields.ID] == '12345' for change in changes) change[StaticFields.ID] == '12345' for change in changes)
self.assertEqual(False, status) self.assertFalse(status)
status = any(change[StaticFields.TYPE] == SWITCH and status = any(change[StaticFields.TYPE] == SWITCH and
change[StaticFields.ID] == '23456' and change[StaticFields.ID] == '23456' and
change[DSProps.EVENT_TYPE] == GraphAction.DELETE_ENTITY change[DSProps.EVENT_TYPE] == GraphAction.DELETE_ENTITY
for change in changes) for change in changes)
self.assertEqual(True, status) self.assertTrue(status)
status = any(change[StaticFields.TYPE] == SWITCH and status = any(change[StaticFields.TYPE] == SWITCH and
change[StaticFields.ID] == '34567' for change in changes) change[StaticFields.ID] == '34567' for change in changes)
self.assertEqual(True, status) self.assertTrue(status)
status = any(change[StaticFields.TYPE] == SWITCH and status = any(change[StaticFields.TYPE] == SWITCH and
change[StaticFields.ID] == '45678' for change in changes) change[StaticFields.ID] == '45678' for change in changes)
self.assertEqual(True, status) self.assertTrue(status)
status = any(change[StaticFields.TYPE] == SWITCH and status = any(change[StaticFields.TYPE] == SWITCH and
change[StaticFields.ID] == '56789' for change in changes) change[StaticFields.ID] == '56789' for change in changes)
self.assertEqual(True, status) self.assertTrue(status)
self.assertEqual(4, len(changes)) self.assertEqual(4, len(changes))

12
vitrage/tests/unit/datasources/static_physical/test_static_physical_transformer.py
View File

@ -81,22 +81,22 @@ class TestStaticPhysicalTransformer(base.BaseTest):
expected_id_values = \ expected_id_values = \
self.transformers[STATIC_PHYSICAL_DATASOURCE]._key_values( self.transformers[STATIC_PHYSICAL_DATASOURCE]._key_values(
switch_type, switch_name) switch_type, switch_name)
self.assertEqual(tuple(observed_id_values), expected_id_values) self.assertEqual(expected_id_values, tuple(observed_id_values))
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(observed_time, timestamp) self.assertEqual(timestamp, observed_time)
observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) observed_subtype = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(observed_subtype, switch_type) self.assertEqual(switch_type, observed_subtype)
observed_entity_id = placeholder.get(VProps.ID) observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(observed_entity_id, switch_name) self.assertEqual(switch_name, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertEqual(vitrage_is_placeholder, True) self.assertTrue(vitrage_is_placeholder)
def test_key_values(self): def test_key_values(self):
LOG.debug('Static Physical transformer test: get key values') LOG.debug('Static Physical transformer test: get key values')

4
vitrage/tests/unit/datasources/test_datasource_update_method.py
View File

@ -190,5 +190,5 @@ class DatasourceUpdateMethod(base.BaseTest):
self.assertNotIn(ZABBIX_DATASOURCE_PULL_NO_INTERVAL, pull_drivers) self.assertNotIn(ZABBIX_DATASOURCE_PULL_NO_INTERVAL, pull_drivers)
def test_datasources_notification_topic(self): def test_datasources_notification_topic(self):
self.assertEqual(self.conf.datasources.notification_topic, self.assertEqual('vitrage_notifications',
'vitrage_notifications') self.conf.datasources.notification_topic)

4
vitrage/tests/unit/datasources/test_rescheduler_functions.py
View File

@ -95,7 +95,7 @@ class ReschedulerTester(base.BaseTest):
fault_interval=FAULT_INTERVAL, fault_interval=FAULT_INTERVAL,
times=RESCHEDULING_TIMES) times=RESCHEDULING_TIMES)
# Test assertions # Test assertions
self.assertEqual(len(self.rescheduler.scheduler.queue), TASKS_NUM) self.assertEqual(TASKS_NUM, len(self.rescheduler.scheduler.queue))
self.reset_test_params() self.reset_test_params()
def test_reset(self): def test_reset(self):
@ -111,7 +111,7 @@ class ReschedulerTester(base.BaseTest):
# Test action # Test action
self.rescheduler.reset() self.rescheduler.reset()
# Test assertions # Test assertions
self.assertEqual(len(self.rescheduler.scheduler.queue), 0) self.assertEqual(0, len(self.rescheduler.scheduler.queue))
self.reset_test_params() self.reset_test_params()
def test_rescheduling(self): def test_rescheduling(self):

8
vitrage/tests/unit/entity_graph/processor/test_processor.py
View File

@ -187,7 +187,7 @@ class TestProcessor(TestEntityGraphUnitBase):
vertex2.vertex_id, vertex2.vertex_id,
'backup') 'backup')
self.assertEqual(3, processor.entity_graph.num_edges()) self.assertEqual(3, processor.entity_graph.num_edges())
self.assertEqual(True, edge_from_graph[EProps.VITRAGE_IS_DELETED]) self.assertTrue(edge_from_graph[EProps.VITRAGE_IS_DELETED])
def test_remove_deleted_entity(self): def test_remove_deleted_entity(self):
# setup # setup
@ -254,9 +254,9 @@ class TestProcessor(TestEntityGraphUnitBase):
vertex.vertex_id, vertex.vertex_id,
neighbor_edge.label) neighbor_edge.label)
self.assertIsNotNone(old_edge) self.assertIsNotNone(old_edge)
self.assertEqual(old_edge[EProps.VITRAGE_IS_DELETED], True) self.assertTrue(old_edge[EProps.VITRAGE_IS_DELETED])
self.assertIsNotNone(new_edge) self.assertIsNotNone(new_edge)
self.assertEqual(new_edge[EProps.VITRAGE_IS_DELETED], False) self.assertFalse(new_edge[EProps.VITRAGE_IS_DELETED])
# update instance with the same neighbor # update instance with the same neighbor
processor._update_neighbors(vertex, neighbors) processor._update_neighbors(vertex, neighbors)
@ -291,7 +291,7 @@ class TestProcessor(TestEntityGraphUnitBase):
neighbor_edge.label) neighbor_edge.label)
self.assertIsNone(old_edge) self.assertIsNone(old_edge)
self.assertIsNotNone(new_edge) self.assertIsNotNone(new_edge)
self.assertEqual(new_edge[EProps.VITRAGE_IS_DELETED], False) self.assertFalse(new_edge[EProps.VITRAGE_IS_DELETED])
# update instance with the same neighbor # update instance with the same neighbor
processor._update_neighbors(vertex, neighbors) processor._update_neighbors(vertex, neighbors)

2
vitrage/tests/unit/evaluator/template_validation/content/base.py
View File

@ -39,7 +39,7 @@ class ValidatorTest(base.BaseTest):
self.assertTrue(result.is_valid_config) self.assertTrue(result.is_valid_config)
self.assertEqual(result.comment, status_msgs[0]) self.assertEqual(result.comment, status_msgs[0])
self.assertEqual(result.status_code, 0) self.assertEqual(0, result.status_code)
def _assert_fault_result(self, result, status_code): def _assert_fault_result(self, result, status_code):

4
vitrage/tests/unit/evaluator/template_validation/test_template_syntax_validator.py
View File

@ -222,7 +222,7 @@ class TemplateSyntaxValidatorTest(base.BaseTest):
# Test assertions # Test assertions
self.assertFalse(result.is_valid_config) self.assertFalse(result.is_valid_config)
self.assertTrue(result.comment.startswith(status_msgs[expected_code])) self.assertTrue(result.comment.startswith(status_msgs[expected_code]))
self.assertEqual(result.status_code, expected_code) self.assertEqual(expected_code, result.status_code)
def _test_execution_with_correct_result(self, template): def _test_execution_with_correct_result(self, template):
@ -232,7 +232,7 @@ class TemplateSyntaxValidatorTest(base.BaseTest):
# Test assertions # Test assertions
self.assertTrue(result.is_valid_config) self.assertTrue(result.is_valid_config)
self.assertEqual(result.comment, status_msgs[0]) self.assertEqual(result.comment, status_msgs[0])
self.assertEqual(result.status_code, 0) self.assertEqual(0, result.status_code)
@staticmethod @staticmethod
def _hide_useless_logging_messages(): def _hide_useless_logging_messages():

6
vitrage/tests/unit/evaluator/test_scenario_repository.py
View File

@ -123,11 +123,11 @@ class EquivalentScenarioTest(base.BaseTest):
for key, scenarios in entity_scenarios.items(): for key, scenarios in entity_scenarios.items():
if (VProps.VITRAGE_CATEGORY, EntityCategory.ALARM) in key: if (VProps.VITRAGE_CATEGORY, EntityCategory.ALARM) in key:
# scenarios expanded on the other alarm # scenarios expanded on the other alarm
self.assertEqual(len(scenarios), 2) self.assertEqual(2, len(scenarios))
if (VProps.VITRAGE_CATEGORY, EntityCategory.RESOURCE) in key: if (VProps.VITRAGE_CATEGORY, EntityCategory.RESOURCE) in key:
# Scenarios expanded on the two alarms. Each alarm is expanded # Scenarios expanded on the two alarms. Each alarm is expanded
# to two equivalent alarms. Thus 2 x 2 = 4 in total # to two equivalent alarms. Thus 2 x 2 = 4 in total
self.assertEqual(len(scenarios), 4) self.assertEqual(4, len(scenarios))
# each relationship is expand to two. Thus 2 x 2 = 4 in total # each relationship is expand to two. Thus 2 x 2 = 4 in total
relationships = self.scenario_repository.relationship_scenarios.keys() relationships = self.scenario_repository.relationship_scenarios.keys()
self.assertEqual(len(relationships), 4) self.assertEqual(4, len(relationships))

12
vitrage/tests/unit/evaluator/test_template_data.py
View File

@ -191,12 +191,12 @@ class BasicTemplateTest(base.BaseTest):
:param entities :param entities
""" """
self.assertIsNotNone(scenarios) self.assertIsNotNone(scenarios)
self.assertEqual(len(scenarios), 1) self.assertEqual(1, len(scenarios))
scenario = scenarios[0] scenario = scenarios[0]
condition = scenario.condition condition = scenario.condition
self.assertEqual(len(condition), 1) self.assertEqual(1, len(condition))
condition_var = condition[0][0] condition_var = condition[0][0]
self.assertIsInstance(condition_var, ConditionVar) self.assertIsInstance(condition_var, ConditionVar)
@ -206,16 +206,16 @@ class BasicTemplateTest(base.BaseTest):
actions = scenario.actions actions = scenario.actions
self.assert_is_not_empty(scenario.actions) self.assert_is_not_empty(scenario.actions)
self.assertEqual(len(actions), 1) self.assertEqual(1, len(actions))
action = actions[0] action = actions[0]
self.assertEqual(action.type, ActionType.SET_STATE) self.assertEqual(action.type, ActionType.SET_STATE)
targets = action.targets targets = action.targets
self.assertEqual(len(targets), 1) self.assertEqual(1, len(targets))
self.assertEqual(targets['target'], 'resource') self.assertEqual('resource', targets['target'])
properties = action.properties properties = action.properties
self.assertEqual(len(properties), 1) self.assertEqual(1, len(properties))
self.assertEqual(properties['state'], self.assertEqual(properties['state'],
OperationalResourceState.SUBOPTIMAL) OperationalResourceState.SUBOPTIMAL)

6
vitrage/tests/unit/notifier/snmp_notifier/test_snmp_sender_with_severity_map.py
View File

@ -56,8 +56,8 @@ class SnmpNotifierTest(base.BaseTest):
oids, var_lst = self.snmp_sender._build_oids() oids, var_lst = self.snmp_sender._build_oids()
self.assertEqual(len(oids), 4) self.assertEqual(4, len(oids))
self.assertEqual(len(var_lst), 3) self.assertEqual(3, len(var_lst))
self.assertIn(VProps.NAME, oids) self.assertIn(VProps.NAME, oids)
self.assertIn(VProps.VITRAGE_IS_DELETED, oids) self.assertIn(VProps.VITRAGE_IS_DELETED, oids)
@ -76,7 +76,7 @@ class SnmpNotifierTest(base.BaseTest):
var_binds = self.snmp_sender._get_var_binds(common.alarm_data) var_binds = self.snmp_sender._get_var_binds(common.alarm_data)
self.assertEqual(len(var_binds), 3) self.assertEqual(3, len(var_binds))
self.assertIn((oid_with_alarm_objects + '.' + common.NAME_OID, self.assertIn((oid_with_alarm_objects + '.' + common.NAME_OID,
OctetString(common.alarm_data.get(VProps.NAME, OctetString(common.alarm_data.get(VProps.NAME,

4
vitrage/tests/unit/notifier/snmp_notifier/test_snmp_sender_without_severity_map.py
View File

@ -55,8 +55,8 @@ class SnmpNotifierTest(base.BaseTest):
oids, var_lst = self.snmp_sender._build_oids() oids, var_lst = self.snmp_sender._build_oids()
self.assertEqual(len(oids), 4) self.assertEqual(4, len(oids))
self.assertEqual(len(var_lst), 3) self.assertEqual(3, len(var_lst))
self.assertIn(VProps.NAME, oids) self.assertIn(VProps.NAME, oids)
self.assertIn(VProps.VITRAGE_IS_DELETED, oids) self.assertIn(VProps.VITRAGE_IS_DELETED, oids)

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

@ -83,9 +83,9 @@ class BaseRcaTest(BaseAlarmsTest):
[VITRAGE_DATASOURCE, VITRAGE_ALARM_NAME, [VITRAGE_DATASOURCE, VITRAGE_ALARM_NAME,
OperationalAlarmSeverity.WARNING]) OperationalAlarmSeverity.WARNING])
self.assertEqual(len(rca), 3) self.assertEqual(3, len(rca))
self.assertEqual(len(resource_alarm), 1) self.assertEqual(1, len(resource_alarm))
self.assertEqual(len(deduce_alarms), 2) self.assertEqual(2, len(deduce_alarms))
def _validate_deduce_alarms(self, alarms, instances): def _validate_deduce_alarms(self, alarms, instances):
"""Validate alarm existence """ """Validate alarm existence """
@ -106,9 +106,9 @@ class BaseRcaTest(BaseAlarmsTest):
NOVA_INSTANCE_DATASOURCE, NOVA_INSTANCE_DATASOURCE,
utils.uni2str(instances[1].id)]) utils.uni2str(instances[1].id)])
self.assertEqual(len(alarms), 3) self.assertEqual(3, len(alarms))
self.assertEqual(len(deduce_alarms_1), 1) self.assertEqual(1, len(deduce_alarms_1))
self.assertEqual(len(deduce_alarms_2), 1) self.assertEqual(1, len(deduce_alarms_2))
def _validate_relationship(self, links, alarms): def _validate_relationship(self, links, alarms):
self.assertNotEqual(len(links), 0, 'The links list is empty') self.assertNotEqual(len(links), 0, 'The links list is empty')
@ -126,7 +126,7 @@ class BaseRcaTest(BaseAlarmsTest):
or target_alarm_name != VITRAGE_ALARM_NAME: or target_alarm_name != VITRAGE_ALARM_NAME:
flag = False flag = False
self.assertEqual(len(alarms), 3) self.assertEqual(3, len(alarms))
self.assertTrue(flag) self.assertTrue(flag)
def _validate_set_state(self, topology, instances): def _validate_set_state(self, topology, instances):
@ -159,9 +159,9 @@ class BaseRcaTest(BaseAlarmsTest):
OperationalResourceState.SUBOPTIMAL, OperationalResourceState.SUBOPTIMAL,
OperationalResourceState.SUBOPTIMAL]) OperationalResourceState.SUBOPTIMAL])
self.assertEqual(len(host), 1) self.assertEqual(1, len(host))
self.assertEqual(len(vm1), 1) self.assertEqual(1, len(vm1))
self.assertEqual(len(vm2), 1) self.assertEqual(1, len(vm2))
def _validate_notifier(self, alarms, vitrage_alarms): def _validate_notifier(self, alarms, vitrage_alarms):
self.assertNotEqual(len(alarms), 0, 'The aodh alarms list is empty') self.assertNotEqual(len(alarms), 0, 'The aodh alarms list is empty')
@ -182,8 +182,8 @@ class BaseRcaTest(BaseAlarmsTest):
validation += 1 validation += 1
break break
self.assertEqual(len(vitrage_alarms), validation) self.assertEqual(validation, len(vitrage_alarms))
self.assertEqual(len(alarms), 3) self.assertEqual(3, len(alarms))
def _get_hostname(self): def _get_hostname(self):
return self._get_value(item=self._get_host(), key=VProps.ID) return self._get_value(item=self._get_host(), key=VProps.ID)

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

@ -108,10 +108,10 @@ class BaseTemplateTest(BaseApiTest):
self, template, validation, path): self, template, validation, path):
self.assertNotEqual(len(validation), 0, self.assertNotEqual(len(validation), 0,
'The template validation is empty') 'The template validation is empty')
self.assertEqual(validation['file path'], path) self.assertEqual(path, validation['file path'])
self.assertEqual(validation['status code'], 0) self.assertEqual(0, validation['status code'])
self.assertEqual(validation['status'], self.OK_STATUS) self.assertEqual(self.OK_STATUS, validation['status'])
self.assertEqual(validation['message'], self.OK_MSG) self.assertEqual(self.OK_MSG, validation['message'])
self.assertEqual(validation['message'], template['status details']) self.assertEqual(validation['message'], template['status details'])
def _run_template_validation( def _run_template_validation(
@ -119,14 +119,14 @@ class BaseTemplateTest(BaseApiTest):
self.assertIn(path, validation['file path']) self.assertIn(path, validation['file path'])
if negative: if negative:
self.assertEqual(validation['status code'], 3) self.assertEqual(3, validation['status code'])
self.assertEqual(validation['status'], self.ERROR_STATUS) self.assertEqual(self.ERROR_STATUS, validation['status'])
self.assertNotEqual(validation['message'], self.OK_MSG) self.assertNotEqual(validation['message'], self.OK_MSG)
return return
self.assertEqual(validation['status code'], 0) self.assertEqual(0, validation['status code'])
self.assertEqual(validation['status'], self.OK_STATUS) self.assertEqual(self.OK_STATUS, validation['status'])
self.assertEqual(validation['message'], self.OK_MSG) self.assertEqual(self.OK_MSG, validation['message'])
def _compare_template_show(self, api_templates, cli_templates): def _compare_template_show(self, api_templates, cli_templates):
self.assertNotEqual(len(api_templates), 0, self.assertNotEqual(len(api_templates), 0,
@ -157,8 +157,8 @@ class BaseTemplateTest(BaseApiTest):
self.assertIn( self.assertIn(
template_show['metadata']['name'], template_content) template_show['metadata']['name'], template_content)
self.assertEqual( self.assertEqual(
len(template_show['definitions']['entities']), entities) entities, len(template_show['definitions']['entities']))
self.assertEqual( self.assertEqual(
len(template_show['definitions']['relationships']), relationships) relationships, len(template_show['definitions']['relationships']))
self.assertEqual( self.assertEqual(
len(template_show['scenarios']), scenarios) scenarios, len(template_show['scenarios']))

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

@ -78,8 +78,8 @@ class TestValidate(BaseTemplateTest):
validation = self.vitrage_client.template.validate(path=path) validation = self.vitrage_client.template.validate(path=path)
self.assertIsNone(validation) self.assertIsNone(validation)
except Exception as up: except Exception as up:
self.assertEqual(up.strerror, 'No such file or directory') self.assertEqual('No such file or directory', up.strerror)
self.assertEqual(up.errno, 2) self.assertEqual(2, up.errno)
def test_templates_validate_corrupted_templates(self): def test_templates_validate_corrupted_templates(self):
"""templates_validate test """templates_validate test
@ -90,7 +90,7 @@ class TestValidate(BaseTemplateTest):
try: try:
path = self.TEST_PATH + self.ERROR_FILE path = self.TEST_PATH + self.ERROR_FILE
validation = self.vitrage_client.template.validate(path=path) validation = self.vitrage_client.template.validate(path=path)
self.assertEqual(len(validation['results']), 1) self.assertEqual(1, len(validation['results']))
self._run_template_validation( self._run_template_validation(
validation['results'][0], path, negative=True) validation['results'][0], path, negative=True)
except Exception: except Exception:
@ -104,7 +104,7 @@ class TestValidate(BaseTemplateTest):
try: try:
path = self.TEST_PATH + self.OK_FILE path = self.TEST_PATH + self.OK_FILE
validation = self.vitrage_client.template.validate(path=path) validation = self.vitrage_client.template.validate(path=path)
self.assertEqual(len(validation['results']), 1) self.assertEqual(1, len(validation['results']))
self._run_template_validation( self._run_template_validation(
validation['results'][0], path) validation['results'][0], path)
except Exception: except Exception:

4
vitrage_tempest_tests/tests/api/topology/test_topology.py
View File

@ -348,8 +348,8 @@ class TestTopology(BaseTopologyTest):
except ClientException as e: except ClientException as e:
self.assertEqual(403, e.code) self.assertEqual(403, e.code)
self.assertEqual( self.assertEqual(
str(e.message), "Graph-type 'graph' requires a 'root' with 'depth'",
"Graph-type 'graph' requires a 'root' with 'depth'") str(e.message))
finally: finally:
self._rollback_to_default() self._rollback_to_default()