openstack/vitrage
Code Issues Proposed changes

Remove test helpers for python < 2.7

Browse Source 
... because wow the minimum python version supported is 3.8.

Change-Id: I9005cd62a1ffcf997a88074f20cad137ccd4121c
This commit is contained in:
Takashi Kajinami
2024-09-03 16:22:38 +09:00
parent 24dd49640d
commit 5702ae0cf8
13 changed files with 44 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
vitrage/tests/base.py
View File

@@ -20,7 +20,6 @@ from oslo_config import fixture as config_fixture
from oslo_utils import timeutils from oslo_utils import timeutils
# noinspection PyPackageRequirements # noinspection PyPackageRequirements
from oslotest import base from oslotest import base
import sys
from testtools import matchers from testtools import matchers
from testtools.matchers import HasLength from testtools.matchers import HasLength
@@ -59,20 +58,6 @@ class BaseTest(base.BaseTestCase):
def config(self, **kw): def config(self, **kw):
self.cfg_fixture.config(**kw) self.cfg_fixture.config(**kw)
def assert_list_equal(self, l1, l2, message=None):
if tuple(sys.version_info)[0:2] < (2, 7):
# for python 2.6 compatibility
self.assertEqual(l1, l2, message)
else:
super(BaseTest, self).assertListEqual(l1, l2, message)
def assert_dict_equal(self, d1, d2, message=None):
if tuple(sys.version_info)[0:2] < (2, 7):
# for python 2.6 compatibility
self.assertEqual(d1, d2)
else:
super(BaseTest, self).assertDictEqual(d1, d2, message)
def assert_timestamp_equal(self, first, second, msg=None): def assert_timestamp_equal(self, first, second, msg=None):
"""Checks that two timestamps are equals. """Checks that two timestamps are equals.
@@ -101,7 +86,7 @@ class BaseTest(base.BaseTestCase):
def assert_graph_equal(self, g1, g2): def assert_graph_equal(self, g1, g2):
"""Checks that two graphs are equals. """Checks that two graphs are equals.
This relies on assert_dict_equal when comparing the nodes and the This relies on assertDictEqual when comparing the nodes and the
edges of each graph. edges of each graph.
""" """
g1_nodes = g1._g.nodes g1_nodes = g1._g.nodes
@@ -113,14 +98,14 @@ class BaseTest(base.BaseTestCase):
self.assertEqual(g1.num_edges(), g2.num_edges(), self.assertEqual(g1.num_edges(), g2.num_edges(),
"Two graphs have different amount of edges") "Two graphs have different amount of edges")
for n_id in g1_nodes: for n_id in g1_nodes:
self.assert_dict_equal(g1_nodes.get(n_id), self.assertDictEqual(g1_nodes.get(n_id),
g2_nodes.get(n_id), g2_nodes.get(n_id),
"Nodes of each graph are not equal") "Nodes of each graph are not equal")
for e_source_id in g1_edges: for e_source_id in g1_edges:
self.assert_dict_equal(dict(g1_edges.get(e_source_id)), self.assertDictEqual(dict(g1_edges.get(e_source_id)),
dict(g2_edges.get(e_source_id)), dict(g2_edges.get(e_source_id)),
"Edges of each graph are not equal") "Edges of each graph are not equal")
def assert_starts_with(self, expected_prefix, observed_str, msg=None): def assert_starts_with(self, expected_prefix, observed_str, msg=None):
self.assertThat(observed_str, self.assertThat(observed_str,

2
vitrage/tests/functional/api/test_versions.py
View File

@@ -33,4 +33,4 @@ class TestVersions(api.FunctionalTest):
def test_versions(self): def test_versions(self):
data = self.get_json('/') data = self.get_json('/')
self.assert_dict_equal(VERSIONS_RESPONSE, data) self.assertDictEqual(VERSIONS_RESPONSE, data)

2
vitrage/tests/functional/api/v1/test_keycloak.py
View File

@@ -105,7 +105,7 @@ class KeycloakTest(FunctionalTest):
resp = self.post_json('/topology/', expect_errors=True) resp = self.post_json('/topology/', expect_errors=True)
self.assertEqual('401 Unauthorized', resp.status) self.assertEqual('401 Unauthorized', resp.status)
self.assert_dict_equal(NO_TOKEN_ERROR_MSG, resp.json) self.assertDictEqual(NO_TOKEN_ERROR_MSG, resp.json)
@mock.patch('jwt.decode', return_value=TOKEN) @mock.patch('jwt.decode', return_value=TOKEN)
@requests_mock.Mocker() @requests_mock.Mocker()

2
vitrage/tests/functional/api/v1/test_service.py
View File

@@ -69,7 +69,7 @@ class ServiceTest(FunctionalTest):
data = self.get_json('/service/') data = self.get_json('/service/')
self.assert_list_equal([ self.assertListEqual([
{ {
'name': name, 'name': name,
'hostname': socket.gethostname(), 'hostname': socket.gethostname(),

2
vitrage/tests/functional/api/v1/test_status.py
View File

@@ -43,7 +43,7 @@ class StatusTest(FunctionalTest):
client.call.return_value = True client.call.return_value = True
request.client.prepare.return_value = client request.client.prepare.return_value = client
resp = self.get_json('/status/') resp = self.get_json('/status/')
self.assert_dict_equal({'reason': 'OK'}, resp) self.assertDictEqual({'reason': 'OK'}, resp)
def test_get_status_not_ok(self): def test_get_status_not_ok(self):
with mock.patch('pecan.request') as request: with mock.patch('pecan.request') as request:

2
vitrage/tests/functional/api/v1/test_template_versions.py
View File

@@ -46,4 +46,4 @@ class TemplateVersionsTest(FunctionalTest):
versions = TemplateApis().template_versions(mock.Mock()) versions = TemplateApis().template_versions(mock.Mock())
request.client.call.return_value = versions request.client.call.return_value = versions
resp = self.get_json('/template/versions/') resp = self.get_json('/template/versions/')
self.assert_list_equal(VERSIONS, resp) self.assertListEqual(VERSIONS, resp)

2
vitrage/tests/functional/datasources/listener_service/test_listener_service.py
View File

@@ -43,7 +43,7 @@ class TestListenerService(base.BaseTest):
self.actual_events = [] self.actual_events = []
def _assert_events(self): def _assert_events(self):
self.assert_list_equal(self.excepted_events, self.actual_events) self.assertListEqual(self.excepted_events, self.actual_events)
def _generate_events(self, update_events): def _generate_events(self, update_events):
gen_list = mock_driver.simple_aodh_alarm_notification_generators( gen_list = mock_driver.simple_aodh_alarm_notification_generators(

6
vitrage/tests/unit/common/test_utils.py
View File

@@ -21,9 +21,9 @@ from vitrage.tests.base import IsEmpty
class UtilsTest(base.BaseTest): class UtilsTest(base.BaseTest):
def _assert_set_equal(self, s1, s2, message): def _assert_set_equal(self, s1, s2, message):
self.assert_dict_equal(dict.fromkeys(s1, 0), self.assertDictEqual(dict.fromkeys(s1, 0),
dict.fromkeys(s2, 0), dict.fromkeys(s2, 0),
message) message)
def test_get_portion(self): def test_get_portion(self):
all_items = list(range(14)) all_items = list(range(14))

8
vitrage/tests/unit/evaluator/template_loading/test_template_loading_v3.py
View File

@@ -97,10 +97,10 @@ class TemplateLoaderV3Test(BaseTest, TestConfiguration):
self.assert_graph_equal(expected_subgraph, observed_subgraph) self.assert_graph_equal(expected_subgraph, observed_subgraph)
# Entities # Entities
self.assert_dict_equal(expected.entities, observed.entities, self.assertDictEqual(expected.entities, observed.entities,
'entities comparison') 'entities comparison')
self.assert_dict_equal(expected.relationships, observed.relationships, self.assertDictEqual(expected.relationships, observed.relationships,
'relationships comparison') 'relationships comparison')
@staticmethod @staticmethod
def _get_yaml(filename): def _get_yaml(filename):

18
vitrage/tests/unit/evaluator/test_template_loader.py
View File

@@ -264,10 +264,10 @@ class TemplateLoaderTest(base.BaseTest):
"""Compare all action fields except from the id""" """Compare all action fields except from the id"""
self.assertEqual(action1.type, action2.type, self.assertEqual(action1.type, action2.type,
'Action types should be equal') 'Action types should be equal')
self.assert_dict_equal(action1.targets, action2.targets, self.assertDictEqual(action1.targets, action2.targets,
'Action targets should be equal') 'Action targets should be equal')
self.assert_dict_equal(action1.properties, action2.properties, self.assertDictEqual(action1.properties, action2.properties,
'Action targets should be equal') 'Action targets should be equal')
def _validate_strict_equal(self, def _validate_strict_equal(self,
template_data, template_data,
@@ -275,12 +275,12 @@ class TemplateLoaderTest(base.BaseTest):
expected_relationships, expected_relationships,
expected_scenario expected_scenario
): ):
self.assert_dict_equal(expected_entities, template_data.entities, self.assertDictEqual(expected_entities, template_data.entities,
'entities not equal') 'entities not equal')
self.assert_dict_equal(expected_relationships, self.assertDictEqual(expected_relationships,
template_data.relationships, template_data.relationships,
'relationship not equal') 'relationship not equal')
self.assertEqual(expected_scenario, template_data.scenarios[0], self.assertEqual(expected_scenario, template_data.scenarios[0],
'scenario not equal') 'scenario not equal')

2
vitrage/tests/unit/graph/base.py
View File

@@ -127,7 +127,7 @@ class GraphTestBase(base.BaseTest):
super(GraphTestBase, self).__init__(*args, **kwds) super(GraphTestBase, self).__init__(*args, **kwds)
def _assert_set_equal(self, d1, d2, message): def _assert_set_equal(self, d1, d2, message):
super(GraphTestBase, self).assert_dict_equal( super(GraphTestBase, self).assertDictEqual(
dict.fromkeys(d1, 0), dict.fromkeys(d2, 0), message) dict.fromkeys(d1, 0), dict.fromkeys(d2, 0), message)
@classmethod @classmethod

26
vitrage/tests/unit/machine_learning/jaccard_correlation/test_jaccard_correlation.py
View File

@@ -206,10 +206,10 @@ class JaccardCorrelationTest(base.BaseTest):
self.data_manager.append_active(alarm_id, timestamp) self.data_manager.append_active(alarm_id, timestamp)
# assert all alarm ids are right # assert all alarm ids are right
self.assert_list_equal(self.alarm_ids, real_alarm_ids) self.assertListEqual(self.alarm_ids, real_alarm_ids)
self.assert_dict_equal(expected_active_start_dict, self.assertDictEqual(expected_active_start_dict,
self.data_manager.active_start_times) self.data_manager.active_start_times)
self.assert_is_empty(self.data_manager.alarms_activity) self.assert_is_empty(self.data_manager.alarms_activity)
self.assert_is_empty(self.data_manager.alarms_intersects) self.assert_is_empty(self.data_manager.alarms_intersects)
@@ -221,8 +221,8 @@ class JaccardCorrelationTest(base.BaseTest):
time.sleep(2) time.sleep(2)
self.data_manager.flush_accumulations() self.data_manager.flush_accumulations()
self.assert_dict_equal(prev_active_start_dict, self.assertDictEqual(prev_active_start_dict,
self.data_manager.active_start_times) self.data_manager.active_start_times)
expected_activity_dict_len = len(ACTIVE_ALARMS) expected_activity_dict_len = len(ACTIVE_ALARMS)
self.assertThat(self.data_manager.alarms_activity, self.assertThat(self.data_manager.alarms_activity,
@@ -257,12 +257,12 @@ class JaccardCorrelationTest(base.BaseTest):
self.data_manager.append_inactive(alarm_id, timestamp) self.data_manager.append_inactive(alarm_id, timestamp)
# assert all deleted alarms has same alarm ids as activated alarms # assert all deleted alarms has same alarm ids as activated alarms
self.assert_list_equal(self.alarm_ids, deleted_alarm_ids) self.assertListEqual(self.alarm_ids, deleted_alarm_ids)
# all alarm are inactive at this moment # all alarm are inactive at this moment
expected_active_start_dict = {} expected_active_start_dict = {}
self.assert_dict_equal(expected_active_start_dict, self.assertDictEqual(expected_active_start_dict,
self.data_manager.active_start_times) self.data_manager.active_start_times)
expected_activity_dict = {} expected_activity_dict = {}
@@ -271,8 +271,8 @@ class JaccardCorrelationTest(base.BaseTest):
self.inactivate_timestamps[alarm_id]\ self.inactivate_timestamps[alarm_id]\
- self.activate_timestamps[alarm_id] - self.activate_timestamps[alarm_id]
self.assert_dict_equal(expected_activity_dict, self.assertDictEqual(expected_activity_dict,
self.data_manager.alarms_activity) self.data_manager.alarms_activity)
expected_intersections_dict = {} expected_intersections_dict = {}
@@ -287,8 +287,8 @@ class JaccardCorrelationTest(base.BaseTest):
self.inactivate_timestamps[alarm_id]\ self.inactivate_timestamps[alarm_id]\
- self.activate_timestamps[alarm_id] - self.activate_timestamps[alarm_id]
self.assert_dict_equal(expected_intersections_dict, self.assertDictEqual(expected_intersections_dict,
self.data_manager.alarms_intersects) self.data_manager.alarms_intersects)
def _test_correlation_collection(self): def _test_correlation_collection(self):
self._test_correlation_list() self._test_correlation_list()
@@ -320,7 +320,7 @@ class JaccardCorrelationTest(base.BaseTest):
correlation) correlation)
cnt += 1 cnt += 1
self.assert_list_equal(alarms_pairs, self.collection.correlation_list) self.assertListEqual(alarms_pairs, self.collection.correlation_list)
def _test_correlations_aggregation(self): def _test_correlations_aggregation(self):

2
vitrage/tests/unit/snmp_parsing/test_snmp_parsing.py
View File

@@ -119,7 +119,7 @@ class TestSnmpParsing(base.BaseTest):
def test_convert_binds_to_dict(self): def test_convert_binds_to_dict(self):
parsing_service = SnmpParsingService(1) parsing_service = SnmpParsingService(1)
dict_converted = parsing_service._convert_binds_to_dict(BINDS_REPORTED) dict_converted = parsing_service._convert_binds_to_dict(BINDS_REPORTED)
self.assert_dict_equal(dict_converted, DICT_EXPECTED) self.assertDictEqual(dict_converted, DICT_EXPECTED)
def test_get_event_type(self): def test_get_event_type(self):
parsing_service = SnmpParsingService(1) parsing_service = SnmpParsingService(1)