openstack/vitrage
Code Issues Proposed changes

plugins tests

Browse Source 
Change-Id: Iaa8b8bb715927ef58dd950557dffd9fe0acdace6
This commit is contained in:
Alexey Weyl 2016-04-04 01:15:53 +03:00
parent bc5d606de5
commit f4d8973ea8
17 changed files with 184 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vitrage/synchronizer/launcher.py
View File

@ -50,7 +50,7 @@ class Launcher(object):
def _register_snapshot_plugins(self):
return {plugin: utils.import_object(self.conf[plugin].synchronizer,
self.conf)
for plugin in self.conf.synchronizer_plugins.plugin_type}
for plugin in self.conf.plugins.plugin_type}
def _register_services(self):
return itertools.chain(

50
vitrage/tests/functional/entity_graph/consistency/test_consistency.py
View File

@ -28,6 +28,7 @@ from vitrage.entity_graph.consistency.consistency_enforcer \
import ConsistencyEnforcer
from vitrage.entity_graph.initialization_status import InitializationStatus
from vitrage.entity_graph.processor.processor import Processor
from vitrage.evaluator.actions.evaluator_event_transformer import VITRAGE_TYPE
from vitrage.evaluator.scenario_evaluator import ScenarioEvaluator
from vitrage.evaluator.scenario_repository import ScenarioRepository
import vitrage.graph.utils as graph_utils
@ -70,30 +71,31 @@ class TestConsistencyFunctional(TestEntityGraphFunctionalBase):
]
# noinspection PyAttributeOutsideInit
def setUp(self):
super(TestConsistencyFunctional, self).setUp()
self.initialization_status = InitializationStatus()
self.conf = cfg.ConfigOpts()
self.conf.register_opts(self.CONSISTENCY_OPTS, group='consistency')
self.conf.register_opts(self.PROCESSOR_OPTS, group='entity_graph')
self.conf.register_opts(self.EVALUATOR_OPTS, group='evaluator')
self.conf.register_opts(self.SYNCHRONIZER_OPTS, group='synchronizer')
self.conf.register_opts(self.PLUGINS_OPTS, group='plugins')
self.load_plugins(self.conf)
@classmethod
def setUpClass(cls):
super(TestConsistencyFunctional, cls).setUpClass()
cls.initialization_status = InitializationStatus()
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.CONSISTENCY_OPTS, group='consistency')
cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph')
cls.conf.register_opts(cls.EVALUATOR_OPTS, group='evaluator')
cls.conf.register_opts(cls.SYNCHRONIZER_OPTS, group='synchronizer')
cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins')
cls.load_plugins(cls.conf)
self.processor = Processor(self.conf, self.initialization_status)
self.event_queue = queue.Queue()
scenario_repo = ScenarioRepository(self.conf)
self.evaluator = ScenarioEvaluator(self.conf,
self.processor.entity_graph,
scenario_repo,
self.event_queue)
self.consistency_enforcer = ConsistencyEnforcer(
self.conf,
self.event_queue,
self.evaluator,
self.processor.entity_graph,
self.initialization_status)
cls.processor = Processor(cls.conf, cls.initialization_status)
cls.event_queue = queue.Queue()
scenario_repo = ScenarioRepository(cls.conf)
cls.evaluator = ScenarioEvaluator(cls.conf,
cls.processor.entity_graph,
scenario_repo,
cls.event_queue)
cls.consistency_enforcer = ConsistencyEnforcer(
cls.conf,
cls.event_queue,
cls.evaluator,
cls.processor.entity_graph,
cls.initialization_status)
@unittest.skip("test_initializing_process skipping")
def test_initializing_process(self):
@ -140,7 +142,7 @@ class TestConsistencyFunctional(TestEntityGraphFunctionalBase):
instance_vertices = self.processor.entity_graph.get_vertices({
VProps.CATEGORY: EntityCategory.ALARM,
VProps.TYPE: self.VITRAGE,
VProps.TYPE: VITRAGE_TYPE,
VProps.IS_DELETED: False
})
self.assertEqual(num_of_host_alarms * num_instances_per_host,

13
vitrage/tests/functional/entity_graph/processor/test_processor.py
View File

@ -29,12 +29,13 @@ class TestProcessorFunctional(TestEntityGraphFunctionalBase):
NUM_EDGES_AFTER_DELETION = 0
# noinspection PyAttributeOutsideInit
def setUp(self):
super(TestProcessorFunctional, self).setUp()
self.conf = cfg.ConfigOpts()
self.conf.register_opts(self.PROCESSOR_OPTS, group='entity_graph')
self.conf.register_opts(self.PLUGINS_OPTS, group='plugins')
self.load_plugins(self.conf)
@classmethod
def setUpClass(cls):
super(TestProcessorFunctional, cls).setUpClass()
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph')
cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins')
cls.load_plugins(cls.conf)
def test_create_entity_graph(self):
processor = self._create_processor_with_graph(self.conf)

13
vitrage/tests/functional/entity_graph/states/test_state_manager.py
View File

@ -30,12 +30,13 @@ from vitrage.tests.functional.entity_graph.base import \
class TestStateManagerFunctional(TestEntityGraphFunctionalBase):
# noinspection PyAttributeOutsideInit
def setUp(self):
super(TestStateManagerFunctional, self).setUp()
self.conf = cfg.ConfigOpts()
self.conf.register_opts(self.PROCESSOR_OPTS, group='entity_graph')
self.conf.register_opts(self.PLUGINS_OPTS, group='plugins')
self.load_plugins(self.conf)
@classmethod
def setUpClass(cls):
super(TestStateManagerFunctional, cls).setUpClass()
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph')
cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins')
cls.load_plugins(cls.conf)
def test_state_on_update(self):
# setup

15
vitrage/tests/mocks/mock_syncronizer.py
View File

@ -191,8 +191,9 @@ def simple_zone_generators(zone_num, host_num, snapshot_events=0,
return tg.get_trace_generators(test_entity_spec_list)
def simple_volume_generators(volume_num, instance_num, snapshot_events=0,
snap_vals=None):
def simple_volume_generators(volume_num, instance_num,
snapshot_events=0, update_events=0,
snap_vals=None, update_vals=None):
"""A function for returning vm event generators.
Returns generators for a given number of volumes and
@ -221,6 +222,16 @@ def simple_volume_generators(volume_num, instance_num, snapshot_events=0,
tg.NUM_EVENTS: snapshot_events
}
)
if update_events:
test_entity_spec_list.append(
{tg.DYNAMIC_INFO_FKEY: tg.SYNC_VOLUME_UPDATE_D,
tg.STATIC_INFO_FKEY: None,
tg.EXTERNAL_INFO_KEY: update_vals,
tg.MAPPING_KEY: mapping,
tg.NAME_KEY: 'Volume update generator',
tg.NUM_EVENTS: update_events
}
)
return tg.get_trace_generators(test_entity_spec_list)

27
vitrage/tests/mocks/trace_generator.py
View File

@ -49,6 +49,7 @@ SYNC_INST_UPDATE_D = 'sync_inst_update_dynamic.json'
SYNC_HOST_SNAPSHOT_D = 'sync_host_snapshot_dynamic.json'
SYNC_ZONE_SNAPSHOT_D = 'sync_zone_snapshot_dynamic.json'
SYNC_VOLUME_SNAPSHOT_D = 'sync_volume_snapshot_dynamic.json'
SYNC_VOLUME_UPDATE_D = 'sync_volume_update_dynamic.json'
SYNC_SWITCH_SNAPSHOT_D = 'sync_switch_snapshot_dynamic.json'
SYNC_NAGIOS_SNAPSHOT_D = 'sync_nagios_snapshot_dynamic.json'
SYNC_NAGIOS_SNAPSHOT_S = 'sync_nagios_snapshot_static.json'
@ -100,6 +101,7 @@ class EventTraceGenerator(object):
SYNC_HOST_SNAPSHOT_D: _get_sync_host_snapshot_values,
SYNC_ZONE_SNAPSHOT_D: _get_sync_zone_snapshot_values,
SYNC_VOLUME_SNAPSHOT_D: _get_sync_volume_snapshot_values,
SYNC_VOLUME_UPDATE_D: _get_sync_volume_update_values,
SYNC_SWITCH_SNAPSHOT_D: _get_sync_switch_snapshot_values,
SYNC_NAGIOS_SNAPSHOT_D: _get_sync_nagios_alarm_values,
@ -284,6 +286,31 @@ def _get_sync_volume_snapshot_values(spec):
return static_values
def _get_sync_volume_update_values(spec):
"""Generates the static synchronizer values for each volume.
:param spec: specification of event generation.
:type spec: dict
:return: list of static synchronizer values for each volume.
:rtype: list
"""
volume_instance_mapping = spec[MAPPING_KEY]
static_info_re = None
if spec[STATIC_INFO_FKEY] is not None:
static_info_re = utils.load_specs(spec[STATIC_INFO_FKEY])
static_values = []
for volume_name, instance_name in volume_instance_mapping:
mapping = {'volume_id': volume_name,
'display_name': volume_name,
'volume_attachment': [{'instance_uuid': instance_name}]}
static_values.append(combine_data(
static_info_re, mapping, spec.get(EXTERNAL_INFO_KEY, None)
))
return static_values
def _get_trans_vm_snapshot_values(spec):
"""Generates the static transformer values for each vm.

11
vitrage/tests/resources/mock_configurations/synchronizer/sync_volume_update_dynamic.json Normal file
View File

@ -0,0 +1,11 @@
{
"volume_attachment": [{"instance_uuid": "54321"}],
"display_name": "volume-0",
"updated_at": "2015-12-01T12:46:41Z",
"status": "In-use",
"volume_id": "12345",
"sync_type": "cinder\\.volume",
"sync_mode": "update",
"event_type": "volume.create.start",
"sample_date": "2015-12-01T12:46:41Z"
}

14
vitrage/tests/unit/entity_graph/processor/base.py
View File

@ -23,13 +23,13 @@ from vitrage.tests.unit.entity_graph.base import TestEntityGraphUnitBase
class TestBaseProcessor(TestEntityGraphUnitBase):
# noinspection PyAttributeOutsideInit
def setUp(self):
super(TestBaseProcessor, self).setUp()
self.conf = cfg.ConfigOpts()
self.conf.register_opts(self.PLUGINS_OPTS,
group='plugins')
self.load_plugins(self.conf)
self.transform = transformer_manager.TransformerManager(self.conf)
@classmethod
def setUpClass(cls):
super(TestBaseProcessor, cls).setUpClass()
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins')
cls.load_plugins(cls.conf)
cls.transform = transformer_manager.TransformerManager(cls.conf)
@staticmethod
def _update_vertex_to_graph(entity_graph, category, type_, id_,

5
vitrage/tests/unit/entity_graph/processor/test_entity_graph.py
View File

@ -19,8 +19,9 @@ from vitrage.tests.unit.entity_graph.processor import base
class TestEntityGraphManager(base.TestBaseProcessor):
def setUp(self):
super(TestEntityGraphManager, self).setUp()
@classmethod
def setUpClass(cls):
super(TestEntityGraphManager, cls).setUpClass()
def test_can_vertex_be_deleted(self):
entity_graph = entity_g.EntityGraph("Entity Graph")

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

@ -41,12 +41,13 @@ class TestProcessor(TestEntityGraphUnitBase):
NUM_EDGES_AFTER_DELETION = 0
# noinspection PyAttributeOutsideInit
def setUp(self):
super(TestProcessor, self).setUp()
self.conf = cfg.ConfigOpts()
self.conf.register_opts(self.PROCESSOR_OPTS, group='entity_graph')
self.conf.register_opts(self.PLUGINS_OPTS, group='plugins')
self.load_plugins(self.conf)
@classmethod
def setUpClass(cls):
super(TestProcessor, cls).setUpClass()
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph')
cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins')
cls.load_plugins(cls.conf)
# TODO(Alexey): un skip this test when instance transformer update is ready
@unittest.skip('Not ready yet')

13
vitrage/tests/unit/entity_graph/states/test_state_manager.py
View File

@ -55,12 +55,13 @@ class TestStateManager(base.BaseTest):
load_plugin(conf, plugin_name, conf.plugins.plugin_path)
# noinspection PyAttributeOutsideInit
def setUp(self):
super(TestStateManager, self).setUp()
self.conf = cfg.ConfigOpts()
self.conf.register_opts(self.ENTITY_GRAPH_OPTS, group='entity_graph')
self.conf.register_opts(self.PLUGINS_OPTS, group='plugins')
self._load_plugins(self.conf)
@classmethod
def setUpClass(cls):
super(TestStateManager, cls).setUpClass()
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.ENTITY_GRAPH_OPTS, group='entity_graph')
cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins')
cls._load_plugins(cls.conf)
def test_load_state_plugins_without_errors(self):
# action

47
vitrage/tests/unit/synchronizer/plugins/cinder/test_cinder_volume_transformer.py
View File

@ -106,7 +106,9 @@ class TestCinderVolumeTransformer(base.BaseTest):
'snapshot')
# Test setup
spec_list = mock_sync.simple_volume_generators(3, 7, 7)
spec_list = mock_sync.simple_volume_generators(volume_num=3,
instance_num=7,
snapshot_events=7)
static_events = mock_sync.generate_random_events_list(spec_list)
for event in static_events:
@ -118,6 +120,29 @@ class TestCinderVolumeTransformer(base.BaseTest):
self._validate_volume_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
self._validate_neighbors(neighbors, vertex.vertex_id, event)
def test_update_transform(self):
LOG.debug('Cinder Volume transformer test: transform entity event '
'update')
# Test setup
spec_list = mock_sync.simple_volume_generators(volume_num=3,
instance_num=7,
update_events=7)
static_events = mock_sync.generate_random_events_list(spec_list)
for event in static_events:
# Test action
wrapper = self.transformers[CINDER_VOLUME_PLUGIN].transform(event)
# Test assertions
vertex = wrapper.vertex
self._validate_volume_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
self._validate_neighbors(neighbors, vertex.vertex_id, event)
def _validate_volume_vertex_props(self, vertex, event):
@ -127,7 +152,7 @@ class TestCinderVolumeTransformer(base.BaseTest):
self.assertEqual(EntityCategory.RESOURCE, vertex[VProps.CATEGORY])
self.assertEqual(event[SyncProps.SYNC_TYPE], vertex[VProps.TYPE])
id_field_path = ('payload', 'instance_id') if is_update_event else 'id'
id_field_path = 'volume_id' if is_update_event else 'id'
self.assertEqual(
tbase.extract_field_value(event, id_field_path),
vertex[VProps.ID])
@ -135,14 +160,12 @@ class TestCinderVolumeTransformer(base.BaseTest):
self.assertEqual(event[SyncProps.SAMPLE_DATE],
vertex[VProps.SAMPLE_TIMESTAMP])
name_field_path = ('payload', 'hostname') \
if is_update_event else 'display_name'
name_field_path = 'display_name'
self.assertEqual(
tbase.extract_field_value(event, name_field_path),
vertex[VProps.NAME])
state_field_path = ('payload', 'state') \
if is_update_event else 'status'
state_field_path = 'status'
self.assertEqual(
tbase.extract_field_value(event, state_field_path),
vertex[VProps.STATE])
@ -154,15 +177,17 @@ class TestCinderVolumeTransformer(base.BaseTest):
instance_counter = 0
for neighbor in neighbors:
self._validate_instance_neighbor(
neighbor,
event['attachments'][0]['server_id'],
volume_vertex_id)
is_update_event = tbase.is_update_event(event)
instance_id = event['volume_attachment'][0]['instance_uuid'] if \
is_update_event else event['attachments'][0]['server_id']
self._validate_instance_neighbor(neighbor,
instance_id,
volume_vertex_id)
instance_counter += 1
self.assertEqual(1,
instance_counter,
'Zone can belongs to only one Node')
'Volume can be belonged to only one instance')
def _validate_instance_neighbor(self,
instance_neighbor,

5
vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_parser.py
View File

@ -52,8 +52,9 @@ class NagiosParserTest(NagiosBaseTest):
u'OK - 0.00 B/sec read, 1.84 MB/sec write, '
u'IOs: 89.00/sec\xa0'}
def setUp(self):
super(NagiosParserTest, self).setUp()
@classmethod
def setUpClass(cls):
super(NagiosParserTest, cls).setUpClass()
def test_template_loader(self):
# Setup

0
vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_alarm_transformer.py → vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_transformer.py
View File

6
vitrage/tests/unit/synchronizer/plugins/nova/test_nova_host_transformer.py
View File

@ -41,8 +41,8 @@ class NovaHostTransformerTest(base.BaseTest):
@classmethod
def setUpClass(cls):
cls.transformers = {}
zone_transformer = ZoneTransformer(cls.transformers)
cls.transformers[NOVA_ZONE_PLUGIN] = zone_transformer
cls.transformers[NOVA_ZONE_PLUGIN] = ZoneTransformer(cls.transformers)
cls.transformers[NOVA_HOST_PLUGIN] = HostTransformer(cls.transformers)
def test_create_placeholder_vertex(self):
LOG.debug('Nova host transformer test: Test create placeholder vertex')
@ -111,7 +111,7 @@ class NovaHostTransformerTest(base.BaseTest):
for event in host_events:
# Test action
wrapper = HostTransformer(self.transformers).transform(event)
wrapper = self.transformers[NOVA_HOST_PLUGIN].transform(event)
# Test assertions
self._validate_vertex_props(wrapper.vertex, event)

51
vitrage/tests/unit/synchronizer/plugins/nova/test_nova_instance_transformers.py
View File

@ -42,8 +42,9 @@ class NovaInstanceTransformerTest(base.BaseTest):
@classmethod
def setUpClass(cls):
cls.transformers = {}
host_transformer = HostTransformer(cls.transformers)
cls.transformers[NOVA_HOST_PLUGIN] = host_transformer
cls.transformers[NOVA_HOST_PLUGIN] = HostTransformer(cls.transformers)
cls.transformers[NOVA_INSTANCE_PLUGIN] = \
InstanceTransformer(cls.transformers)
def test_create_placeholder_vertex(self):
LOG.debug('Test create placeholder vertex')
@ -88,33 +89,26 @@ class NovaInstanceTransformerTest(base.BaseTest):
'snapshot and snapshot init events')
# Test setup
spec_list = mock_sync.simple_instance_generators(
host_num=1,
vm_num=1,
snapshot_events=10,
update_events=0
)
spec_list = mock_sync.simple_instance_generators(host_num=1,
vm_num=1,
snapshot_events=10,
update_events=0)
instance_events = mock_sync.generate_random_events_list(spec_list)
for event in instance_events:
# Test action
instance_transformer = InstanceTransformer(self.transformers)
wrapper = instance_transformer.transform(event)
wrapper = self.transformers[NOVA_INSTANCE_PLUGIN].transform(event)
# Test assertions
self._validate_vertex_props(wrapper.vertex, event)
# Validate the neighbors: only one valid host neighbor
self.assertEqual(
1,
len(wrapper.neighbors),
'Instance has only one host neighbor'
)
self.assertEqual(1,
len(wrapper.neighbors),
'Instance has only one host neighbor')
host_neighbor = wrapper.neighbors[0]
self._validate_host_neighbor(host_neighbor, event)
sync_mode = event[SyncProps.SYNC_MODE]
if sync_mode == SyncMode.INIT_SNAPSHOT:
self.assertEqual(EventAction.CREATE_ENTITY, wrapper.action)
elif sync_mode == SyncMode.SNAPSHOT:
@ -124,30 +118,23 @@ class NovaInstanceTransformerTest(base.BaseTest):
LOG.debug('Test tactual transform action for update events')
# Test setup
spec_list = mock_sync.simple_instance_generators(
host_num=1,
vm_num=1,
snapshot_events=0,
update_events=10
)
spec_list = mock_sync.simple_instance_generators(host_num=1,
vm_num=1,
snapshot_events=0,
update_events=10)
instance_events = mock_sync.generate_random_events_list(spec_list)
for event in instance_events:
# Test action
instance_transformer = InstanceTransformer(self.transformers)
wrapper = instance_transformer.transform(event)
wrapper = self.transformers[NOVA_INSTANCE_PLUGIN].transform(event)
# Test assertions
self._validate_vertex_props(wrapper.vertex, event)
# Validate the neighbors: only one valid host neighbor
self.assertEqual(
1,
len(wrapper.neighbors),
'Instance has only one host neighbor'
)
host_neighbor = wrapper.neighbors[0]
self._validate_host_neighbor(host_neighbor, event)
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
self._validate_host_neighbor(neighbors[0], event)
event_type = event[SyncProps.EVENT_TYPE]
if event_type == 'compute.instance.delete.end':

15
vitrage/tests/unit/synchronizer/plugins/nova/test_nova_zone_transformer.py
View File

@ -40,8 +40,8 @@ class NovaZoneTransformerTest(base.BaseTest):
@classmethod
def setUpClass(cls):
cls.transformers = {}
host_transformer = HostTransformer(cls.transformers)
cls.transformers[NOVA_HOST_PLUGIN] = host_transformer
cls.transformers[NOVA_HOST_PLUGIN] = HostTransformer(cls.transformers)
cls.transformers[NOVA_ZONE_PLUGIN] = ZoneTransformer(cls.transformers)
def test_create_placeholder_vertex(self):
@ -108,22 +108,21 @@ class NovaZoneTransformerTest(base.BaseTest):
LOG.debug('Nova zone transformer test: transform entity event')
# Test setup
spec_list = mock_sync.simple_zone_generators(
zone_num=2,
host_num=3,
snapshot_events=5
)
spec_list = mock_sync.simple_zone_generators(zone_num=1,
host_num=1,
snapshot_events=5)
zone_events = mock_sync.generate_random_events_list(spec_list)
for event in zone_events:
# Test action
wrapper = ZoneTransformer(self.transformers).transform(event)
wrapper = self.transformers[NOVA_ZONE_PLUGIN].transform(event)
# Test assertions
vertex = wrapper.vertex
self._validate_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self.assertEqual(2, len(neighbors))
self._validate_neighbors(neighbors, vertex.vertex_id, event)
def _validate_neighbors(self, neighbors, zone_vertex_id, event):