def test_extract_event_action(self):
LOG.debug('Test extract event action')
# Test setup
spec_list = mock_sync.simple_host_generators(
zone_num=1,
host_num=1,
snapshot_events=1,
snap_vals={DSProps.DATASOURCE_ACTION: DatasourceAction.SNAPSHOT})
hosts_events = mock_sync.generate_random_events_list(spec_list)
host_transformer = self.transformers[NOVA_HOST_DATASOURCE]
# Test action
action = host_transformer._extract_graph_action(hosts_events[0])
# Test assertion
self.assertEqual(GraphAction.UPDATE_ENTITY, action)
# Test setup
spec_list = mock_sync.simple_host_generators(
zone_num=1,
host_num=1,
snapshot_events=1,
snap_vals={DSProps.DATASOURCE_ACTION:
DatasourceAction.INIT_SNAPSHOT})
hosts_events = mock_sync.generate_random_events_list(spec_list)
host_transformer = self.transformers[NOVA_HOST_DATASOURCE]
# Test action
action = host_transformer._extract_graph_action(hosts_events[0])
# Test assertions
self.assertEqual(GraphAction.CREATE_ENTITY, action)
def test_extract_event_action(self):
LOG.debug('Test extract event action')
# Test setup
spec_list = mock_sync.simple_host_generators(
zone_num=1,
host_num=1,
snapshot_events=1,
snap_vals={DSProps.DATASOURCE_ACTION: DatasourceAction.SNAPSHOT})
hosts_events = mock_sync.generate_random_events_list(spec_list)
host_transformer = self.transformers[NOVA_HOST_DATASOURCE]
# Test action
action = host_transformer._extract_graph_action(hosts_events[0])
# Test assertion
self.assertEqual(GraphAction.UPDATE_ENTITY, action)
# Test setup
spec_list = mock_sync.simple_host_generators(
zone_num=1,
host_num=1,
snapshot_events=1,
snap_vals={DSProps.DATASOURCE_ACTION:
DatasourceAction.INIT_SNAPSHOT})
hosts_events = mock_sync.generate_random_events_list(spec_list)
host_transformer = self.transformers[NOVA_HOST_DATASOURCE]
# Test action
action = host_transformer._extract_graph_action(hosts_events[0])
# Test assertions
self.assertEqual(GraphAction.CREATE_ENTITY, action)
def test_extract_action_type(self):
LOG.debug('Test extract action type')
# Test setup
spec_list = mock_sync.simple_host_generators(
zone_num=1,
host_num=1,
snapshot_events=1,
snap_vals={DSProps.SYNC_MODE: SyncMode.SNAPSHOT})
hosts_events = mock_sync.generate_random_events_list(spec_list)
host_transformer = HostTransformer(self.transformers)
# Test action
action = host_transformer._extract_action_type(hosts_events[0])
# Test assertion
self.assertEqual(EventAction.UPDATE_ENTITY, action)
# Test setup
spec_list = mock_sync.simple_host_generators(
zone_num=1,
host_num=1,
snapshot_events=1,
snap_vals={DSProps.SYNC_MODE: SyncMode.INIT_SNAPSHOT})
hosts_events = mock_sync.generate_random_events_list(spec_list)
host_transformer = HostTransformer(self.transformers)
# Test action
action = host_transformer._extract_action_type(hosts_events[0])
# Test assertions
self.assertEqual(EventAction.CREATE_ENTITY, action)
def test_overlapping_deduced_alarm_1(self):
event_queue, processor, evaluator = self._init_system()
# generate WARNING nagios alarm
vals = {'status': 'WARNING', 'service': 'cause_warning_deduced_alarm'}
vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('WARNING', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# generate CRITICAL nagios alarm to trigger
vals = {'status': 'CRITICAL',
'service': 'cause_critical_deduced_alarm'}
vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, vals)
critical_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(2, len(causes))
# remove WARNING nagios alarm, leaving only CRITICAL one
warning_test['status'] = 'OK'
warning_test[DSProps.EVENT_TYPE] = GraphAction.DELETE_ENTITY
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# next disable the alarm
critical_test['status'] = 'OK'
critical_test[DSProps.EVENT_TYPE] = GraphAction.DELETE_ENTITY
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(0, len(alarms))
def test_overlapping_deduced_alarm_1(self):
event_queue, processor, evaluator = self._init_system()
# generate WARNING nagios alarm
vals = {'status': 'WARNING', 'service': 'cause_warning_deduced_alarm'}
vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('WARNING', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# generate CRITICAL nagios alarm to trigger
vals = {
'status': 'CRITICAL',
'service': 'cause_critical_deduced_alarm'
}
vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, vals)
critical_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(2, len(causes))
# remove WARNING nagios alarm, leaving only CRITICAL one
warning_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# next disable the alarm
critical_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(0, len(alarms))
def test_deduced_state(self):
event_queue, processor, evaluator = self._init_system()
host_v = self._get_host_from_graph(_TARGET_HOST,
processor.entity_graph)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when starting')
# generate nagios alarm to trigger template scenario
test_vals = {'status': 'WARNING', 'service': 'cause_suboptimal_state'}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
self.assertEqual('SUBOPTIMAL', host_v[VProps.AGGREGATED_STATE],
'host should be SUBOPTIMAL with warning alarm')
# next disable the alarm
warning_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when alarm disabled')
def test_deduced_alarm(self):
event_queue, processor, evaluator = self._init_system()
host_v = self._get_host_from_graph(_TARGET_HOST,
processor.entity_graph)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when starting')
# generate CRITICAL nagios alarm to trigger
test_vals = {'status': 'WARNING',
'service': 'cause_warning_deduced_alarm'}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('WARNING', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# next disable the alarm
warning_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(0, len(alarms))
def test_deduced_state(self):
event_queue, processor, evaluator = self._init_system()
host_v = self._get_host_from_graph(_TARGET_HOST,
processor.entity_graph)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when starting')
# generate nagios alarm to trigger template scenario
test_vals = {'status': 'WARNING', 'service': 'cause_suboptimal_state'}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
self.assertEqual('SUBOPTIMAL', host_v[VProps.AGGREGATED_STATE],
'host should be SUBOPTIMAL with warning alarm')
# next disable the alarm
warning_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when alarm disabled')
def test_deduced_alarm(self):
event_queue, processor, evaluator = self._init_system()
host_v = self._get_host_from_graph(_TARGET_HOST,
processor.entity_graph)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when starting')
# generate CRITICAL nagios alarm to trigger
test_vals = {
'status': 'WARNING',
'service': 'cause_warning_deduced_alarm'
}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('WARNING', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# next disable the alarm
warning_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(0, len(alarms))
def test_update_transform(self):
LOG.debug('Test transform entity update event')
# Test setup
spec_list = mock_sync.simple_switch_generators(2, 10, 0, None, 10)
static_events = mock_sync.generate_random_events_list(spec_list)
self._events_transform_test(static_events)
def test_update_event_transform(self):
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)
instance_events = mock_sync.generate_random_events_list(spec_list)
for event in instance_events:
# Test action
wrapper = self.transformers[NOVA_INSTANCE_DATASOURCE].transform(
event)
# Test assertions
self._validate_vertex_props(wrapper.vertex, event)
# Validate the neighbors: only one valid host neighbor
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
self._validate_host_neighbor(neighbors[0], event)
event_type = event[DSProps.EVENT_TYPE]
if event_type == 'compute.instance.delete.end':
self.assertEqual(GraphAction.DELETE_ENTITY, wrapper.action)
elif event_type == 'compute.instance.create.start':
self.assertEqual(GraphAction.CREATE_ENTITY, wrapper.action)
else:
self.assertEqual(GraphAction.UPDATE_ENTITY, wrapper.action)
def test_snapshot_event_transform(self):
LOG.debug('Test tactual transform action for '
'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)
instance_events = mock_sync.generate_random_events_list(spec_list)
for event in instance_events:
# Test action
wrapper = self.transformers[NOVA_INSTANCE_DATASOURCE].transform(
event)
# Test assertions
self._validate_vertex_props(wrapper.vertex, event)
self.assertEqual(1,
len(wrapper.neighbors),
'Instance has only one host neighbor')
host_neighbor = wrapper.neighbors[0]
self._validate_host_neighbor(host_neighbor, event)
datasource_action = event[DSProps.DATASOURCE_ACTION]
if datasource_action == DatasourceAction.INIT_SNAPSHOT:
self.assertEqual(GraphAction.CREATE_ENTITY, wrapper.action)
elif datasource_action == DatasourceAction.SNAPSHOT:
self.assertEqual(GraphAction.UPDATE_ENTITY, wrapper.action)
def test_cinder_volume_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
spec_list = mock_driver.simple_volume_generators(volume_num=1,
instance_num=1,
snapshot_events=1)
static_events = mock_driver.generate_random_events_list(spec_list)
cinder_volume_event = static_events[0]
cinder_volume_event['attachments'][0]['server_id'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_INSTANCE_DATASOURCE)
# Action
processor.process_event(cinder_volume_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 1,
len(processor.entity_graph))
cinder_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE
})
self.assertEqual(1, len(cinder_vertices))
cinder_neighbors = processor.entity_graph.neighbors(
cinder_vertices[0].vertex_id)
self.assertEqual(1, len(cinder_neighbors))
self.assertEqual(NOVA_INSTANCE_DATASOURCE,
cinder_neighbors[0][VProps.VITRAGE_TYPE])
def test_snapshot_transform(self):
LOG.debug('Nova host transformer test: transform entity event')
# Test setup
spec_list = mock_sync.simple_host_generators(zone_num=2,
host_num=4,
snapshot_events=5)
host_events = mock_sync.generate_random_events_list(spec_list)
for event in host_events:
# Test action
wrapper = self.transformers[NOVA_HOST_DATASOURCE].transform(event)
# Test assertions
self._validate_vertex_props(wrapper.vertex, event)
neighbors = wrapper.neighbors
self.assertThat(neighbors, matchers.HasLength(1))
self._validate_zone_neighbor(neighbors[0], event)
if DatasourceAction.SNAPSHOT == event[DSProps.DATASOURCE_ACTION]:
self.assertEqual(GraphAction.UPDATE_ENTITY, wrapper.action)
else:
self.assertEqual(GraphAction.CREATE_ENTITY, wrapper.action)
def test_update_event_transform(self):
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)
instance_events = mock_sync.generate_random_events_list(spec_list)
for event in instance_events:
# Test action
wrapper = self.transformers[NOVA_INSTANCE_DATASOURCE].transform(
event)
# Test assertions
self._validate_vertex_props(wrapper.vertex, event)
# Validate the neighbors: only one valid host neighbor
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
self._validate_host_neighbor(neighbors[0], event)
event_type = event[DSProps.EVENT_TYPE]
if event_type == 'compute.instance.delete.end':
self.assertEqual(GraphAction.DELETE_ENTITY, wrapper.action)
elif event_type == 'compute.instance.create.start':
self.assertEqual(GraphAction.CREATE_ENTITY, wrapper.action)
else:
self.assertEqual(GraphAction.UPDATE_ENTITY, wrapper.action)
def test_snapshot_event_transform(self):
LOG.debug('Test tactual transform action for '
'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)
instance_events = mock_sync.generate_random_events_list(spec_list)
for event in instance_events:
# Test action
wrapper = self.transformers[NOVA_INSTANCE_DATASOURCE].transform(
event)
# Test assertions
self._validate_vertex_props(wrapper.vertex, event)
self.assertEqual(1,
len(wrapper.neighbors),
'Instance has only one host neighbor')
host_neighbor = wrapper.neighbors[0]
self._validate_host_neighbor(host_neighbor, event)
datasource_action = event[DSProps.DATASOURCE_ACTION]
if datasource_action == DatasourceAction.INIT_SNAPSHOT:
self.assertEqual(GraphAction.CREATE_ENTITY, wrapper.action)
elif datasource_action == DatasourceAction.SNAPSHOT:
self.assertEqual(GraphAction.UPDATE_ENTITY, wrapper.action)
def test_snapshot_transform(self):
LOG.debug('Nova host transformer test: transform entity event')
# Test setup
spec_list = mock_sync.simple_host_generators(zone_num=2,
host_num=4,
snapshot_events=5)
host_events = mock_sync.generate_random_events_list(spec_list)
for event in host_events:
# Test action
wrapper = self.transformers[NOVA_HOST_DATASOURCE].transform(event)
# Test assertions
self._validate_vertex_props(wrapper.vertex, event)
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
self._validate_zone_neighbor(neighbors[0], event)
if SyncMode.SNAPSHOT == event[DSProps.SYNC_MODE]:
self.assertEqual(EventAction.UPDATE_ENTITY, wrapper.action)
else:
self.assertEqual(EventAction.CREATE_ENTITY, wrapper.action)
def test_snapshot_event_transform(self):
LOG.debug('Test tactual transform action for '
'snapshot and snapshot init events')
k8s_spec_list = \
mock_sync.simple_k8s_nodes_generators(nodes_num=2,
snapshot_events=1)
nodes_events = mock_sync.generate_random_events_list(k8s_spec_list)
for event in nodes_events:
k8s_wrapper = self.transformers[KUBERNETES_DATASOURCE].transform(
event)
# Test assertions
self.assertEqual(cluster_name, k8s_wrapper.vertex[VProps.NAME])
n_length = str(len(k8s_wrapper.neighbors))
self.assertThat(n_length, matchers.HasLength(1),
'Cluster vertex has one neighbor')
self._validate_cluster_neighbors(k8s_wrapper.neighbors, event)
datasource_action = event[DSProps.DATASOURCE_ACTION]
if datasource_action == DatasourceAction.INIT_SNAPSHOT:
self.assertEqual(GraphAction.CREATE_ENTITY, k8s_wrapper.action)
elif datasource_action == DatasourceAction.SNAPSHOT:
self.assertEqual(GraphAction.UPDATE_ENTITY, k8s_wrapper.action)
def _create_events():
spec_list = mock_sync.simple_instance_generators(
host_num=1, vm_num=1, update_events=1,
use_nova_versioned_format=True
)
update_versioned_event = \
mock_sync.generate_random_events_list(spec_list)[0]
spec_list = mock_sync.simple_instance_generators(
host_num=1, vm_num=1, update_events=1,
use_nova_versioned_format=False
)
update_legacy_event = \
mock_sync.generate_random_events_list(spec_list)[0]
return update_versioned_event, update_legacy_event
def test_snapshot_transform(self):
LOG.debug('Test transform entity snapshot/snapshot_init event')
# Test setup
spec_list = mock_sync.simple_switch_generators(2, 10, 10)
static_events = mock_sync.generate_random_events_list(spec_list)
self._events_transform_test(static_events)
def test_nagios_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf, uuid=True)
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
spec_list = mock_driver.simple_nagios_alarm_generators(host_num=1,
events_num=1)
static_events = mock_driver.generate_random_events_list(spec_list)
nagios_event = static_events[0]
nagios_event['resource_name'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
nagios_event['status'] = 'critical'
# Action
processor.process_event(nagios_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 1,
len(processor.entity_graph))
nagios_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.ALARM,
VProps.TYPE: NAGIOS_DATASOURCE
})
self.assertEqual(1, len(nagios_vertices))
nagios_neighbors = processor.entity_graph.neighbors(
nagios_vertices[0].vertex_id)
self.assertEqual(1, len(nagios_neighbors))
self.assertEqual(NOVA_HOST_DATASOURCE,
nagios_neighbors[0][VProps.TYPE])
def test_create_entity_key(self):
LOG.debug('Test get key from nova instance transformer')
# Test setup
spec_list = mock_sync.simple_instance_generators(host_num=1,
vm_num=1,
snapshot_events=1,
update_events=0)
instance_events = mock_sync.generate_random_events_list(spec_list)
instance_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE]
for event in instance_events:
# Test action
observed_key = instance_transformer._create_entity_key(event)
# Test assertions
observed_key_fields = observed_key.split(
TransformerBase.KEY_SEPARATOR)
self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0])
self.assertEqual(NOVA_INSTANCE_DATASOURCE, observed_key_fields[1])
instance_id = tbase.extract_field_value(event, 'id')
self.assertEqual(instance_id, observed_key_fields[2])
key_values = instance_transformer._key_values(
NOVA_INSTANCE_DATASOURCE, instance_id)
expected_key = tbase.build_key(key_values)
self.assertEqual(expected_key, observed_key)
def test_snapshot_transform(self):
LOG.debug('Test transform entity snapshot/snapshot_init event')
# Test setup
spec_list = mock_sync.simple_switch_generators(2, 10, 10)
static_events = mock_sync.generate_random_events_list(spec_list)
self._events_transform_test(static_events)
def test_update_transform(self):
LOG.debug('Test transform entity update event')
# Test setup
spec_list = mock_sync.simple_switch_generators(2, 10, 0, None, 10)
static_events = mock_sync.generate_random_events_list(spec_list)
self._events_transform_test(static_events)
def test_create_entity_key(self):
LOG.debug('Test get key from kubernetes transformer')
# Test setup
spec_list = mock_sync.simple_k8s_nodes_generators(nodes_num=1,
snapshot_events=1)
nodes_events = mock_sync.generate_random_events_list(spec_list)
kubernetes_transformer = self.transformers[KUBERNETES_DATASOURCE]
for event in nodes_events:
# Test action
observed_key = kubernetes_transformer._create_entity_key(event)
# Test assertions
observed_key_fields = observed_key.split(
TransformerBase.KEY_SEPARATOR)
self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0])
self.assertEqual(
KUBERNETES_DATASOURCE,
observed_key_fields[1]
)
key_values = kubernetes_transformer._key_values(
KUBERNETES_DATASOURCE,
cluster_name)
expected_key = tbase.build_key(key_values)
self.assertEqual(expected_key, observed_key)
def test_update_event_transform(self):
LOG.debug('Test actual transform action for update events')
# Test setup
spec_list = mock_sync.simple_instance_generators(
host_num=1, vm_num=1, update_events=10,
use_nova_versioned_format=False
)
instance_events = mock_sync.generate_random_events_list(spec_list)
self._test_update_event_transform(instance_events)
def test_overlapping_deduced_alarm_2(self):
event_queue, processor, evaluator = self._init_system()
# generate CRITICAL nagios alarm to trigger
test_vals = {'status': 'CRITICAL',
'service': 'cause_critical_deduced_alarm'}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
critical_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
# generate WARNING nagios alarm to trigger
test_vals = {'status': 'WARNING',
'service': 'cause_warning_deduced_alarm'}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
# remove CRITICAL nagios alarm, leaving only WARNING one
critical_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('WARNING', alarms[0]['severity'])
def test_heat_stack_validity(self):
# Setup
processor = self._create_processor_with_graph()
self.assertThat(processor.entity_graph,
matchers.HasLength(
self._num_total_expected_vertices())
)
spec_list = mock_driver.simple_stack_generators(
stack_num=1,
instance_and_volume_num=1,
snapshot_events=1)
static_events = mock_driver.generate_random_events_list(spec_list)
heat_stack_event = static_events[0]
# Action
processor.process_event(heat_stack_event)
# Test assertions
self.assertThat(processor.entity_graph,
matchers.HasLength(
self._num_total_expected_vertices() + 3)
)
stack_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_TYPE: HEAT_STACK_DATASOURCE
})
self.assertThat(stack_vertices, matchers.HasLength(1))
instance_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE
})
self.assertThat(instance_vertices,
matchers.HasLength(self.NUM_INSTANCES + 1))
cinder_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE
})
self.assertThat(cinder_vertices, matchers.HasLength(1))
stack_neighbors = processor.entity_graph.neighbors(
stack_vertices[0].vertex_id)
self.assertThat(stack_neighbors, matchers.HasLength(2))
def test_snapshot_transform(self):
LOG.debug("Nova zone transformer test: transform entity event")
# Test setup
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 = self.transformers[NOVA_ZONE_DATASOURCE].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 test_heat_stack_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
spec_list = mock_driver.simple_stack_generators(
stack_num=1,
instance_and_volume_num=1,
snapshot_events=1)
static_events = mock_driver.generate_random_events_list(spec_list)
heat_stack_event = static_events[0]
# Action
processor.process_event(heat_stack_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 3,
len(processor.entity_graph))
stack_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.RESOURCE,
VProps.TYPE: HEAT_STACK_DATASOURCE
})
self.assertEqual(1, len(stack_vertices))
instance_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.RESOURCE,
VProps.TYPE: NOVA_INSTANCE_DATASOURCE
})
self.assertEqual(self.NUM_INSTANCES + 1, len(instance_vertices))
cinder_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.RESOURCE,
VProps.TYPE: CINDER_VOLUME_DATASOURCE
})
self.assertEqual(1, len(cinder_vertices))
stack_neighbors = processor.entity_graph.neighbors(
stack_vertices[0].vertex_id)
self.assertEqual(2, len(stack_neighbors))
def _create_event(spec_type=None, sync_mode=None,
event_type=None, properties=None):
# generate event
spec_list = mock_sync.simple_instance_generators(1, 1, 1)
events_list = mock_sync.generate_random_events_list(
spec_list)
# update properties
if sync_mode is not None:
events_list[0][DSProps.SYNC_MODE] = sync_mode
if event_type is not None:
events_list[0][DSProps.EVENT_TYPE] = event_type
if properties is not None:
for key, value in properties.items():
events_list[0][key] = value
return events_list[0]
def test_static_physical_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
transformers = processor.transformer_manager.transformers
transformers[SWITCH] = transformers[STATIC_PHYSICAL_DATASOURCE]
self.assertThat(processor.entity_graph,
matchers.HasLength(
self._num_total_expected_vertices())
)
spec_list = mock_driver.simple_switch_generators(
switch_num=1,
host_num=1,
snapshot_events=1)
static_events = mock_driver.generate_random_events_list(spec_list)
static_physical_event = static_events[0]
static_physical_event[DSProps.ENTITY_TYPE] = SWITCH
static_physical_event['relationships'][0]['name'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
# Action
processor.process_event(static_physical_event)
# Test assertions
self.assertThat(processor.entity_graph,
matchers.HasLength(
self._num_total_expected_vertices() + 1)
)
static_physical_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_TYPE: SWITCH
})
self.assertThat(static_physical_vertices, matchers.HasLength(1))
static_physical_neighbors = processor.entity_graph.neighbors(
static_physical_vertices[0].vertex_id)
self.assertThat(static_physical_neighbors, matchers.HasLength(1))
self.assertEqual(NOVA_HOST_DATASOURCE,
static_physical_neighbors[0][VProps.VITRAGE_TYPE])
def test_snapshot_event_transform(self):
# Test setup
spec_list = mock_sync.simple_trove_cluster_generators(
clust_num=1, inst_num=1, snapshot_events=10)
events = mock_sync.generate_random_events_list(spec_list)
for event in events:
# Test action
transformer = self.transformers[TROVE_CLUSTER_DATASOURCE]
wrapper = transformer.transform(event)
# Test assertions
vertex = wrapper.vertex
self._validate_vertex_props(vertex, event)
neighbours = wrapper.neighbors
self.assertThat(neighbours, matchers.HasLength(1))
self._validate_server_neighbour(neighbours[0], vertex.vertex_id,
event)
def test_heat_stack_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf, uuid=True)
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
spec_list = mock_driver.simple_stack_generators(
stack_num=1, instance_and_volume_num=1, snapshot_events=1)
static_events = mock_driver.generate_random_events_list(spec_list)
heat_stack_event = static_events[0]
# Action
processor.process_event(heat_stack_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 3,
len(processor.entity_graph))
stack_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.RESOURCE,
VProps.TYPE: HEAT_STACK_DATASOURCE
})
self.assertEqual(1, len(stack_vertices))
instance_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.RESOURCE,
VProps.TYPE: NOVA_INSTANCE_DATASOURCE
})
self.assertEqual(self.NUM_INSTANCES + 1, len(instance_vertices))
cinder_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.RESOURCE,
VProps.TYPE: CINDER_VOLUME_DATASOURCE
})
self.assertEqual(1, len(cinder_vertices))
stack_neighbors = processor.entity_graph.neighbors(
stack_vertices[0].vertex_id)
self.assertEqual(2, len(stack_neighbors))
def _create_event(spec_type=None,
datasource_action=None,
event_type=None,
properties=None):
# generate event
spec_list = mock_sync.simple_instance_generators(1, 1, 1)
events_list = mock_sync.generate_random_events_list(spec_list)
# update properties
if datasource_action is not None:
events_list[0][DSProps.DATASOURCE_ACTION] = datasource_action
if event_type is not None:
events_list[0][DSProps.EVENT_TYPE] = event_type
if properties is not None:
for key, value in properties.items():
events_list[0][key] = value
return events_list[0]
def _create_event(spec_type=None,
sync_mode=None,
event_type=None,
properties=None):
# generate event
spec_list = mock_sync.simple_instance_generators(1, 1, 1)
events_list = mock_sync.generate_random_events_list(spec_list)
# update properties
if sync_mode is not None:
events_list[0][DSProps.SYNC_MODE] = sync_mode
if event_type is not None:
events_list[0][DSProps.EVENT_TYPE] = event_type
if properties is not None:
for key, value in properties.items():
events_list[0][key] = value
return events_list[0]
def test_update_transform(self):
LOG.debug("Consistency transformer test: transform entity event " "update")
# Test setup
spec_list = mock_sync.simple_consistency_generators(consistency_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[CONSISTENCY_DATASOURCE].transform(event)
# Test assertions
vertex = wrapper.vertex
self._validate_consistency_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self.assertIsNone(neighbors)
action = wrapper.action
self.assertIn(action, self.actions)
def test_snapshot_transform(self):
LOG.debug('Nova zone transformer test: transform entity event')
# Test setup
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 = self.transformers[NOVA_ZONE_DATASOURCE].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 _create_event(spec_type=None,
datasource_action=None,
event_type=None,
properties=None):
# generate event
spec_list = mock_sync.simple_instance_generators(1, 1, 1)
events_list = mock_sync.generate_random_events_list(
spec_list)
# update properties
if datasource_action is not None:
events_list[0][DSProps.DATASOURCE_ACTION] = datasource_action
if event_type is not None:
events_list[0][DSProps.EVENT_TYPE] = event_type
if properties is not None:
for key, value in properties.items():
events_list[0][key] = value
return events_list[0]
def test_update_transform(self):
LOG.debug('Heat Stack transformer test: transform entity event '
'update')
# Test setup
spec_list = \
mock_sync.simple_stack_generators(stack_num=3,
instance_and_volume_num=7,
snapshot_events=7)
static_events = mock_sync.generate_random_events_list(spec_list)
for event in static_events:
# Test action
wrapper = self.transformers[HEAT_STACK_DATASOURCE].transform(event)
# Test assertions
vertex = wrapper.vertex
self._validate_stack_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self._validate_neighbors(neighbors, vertex.vertex_id, event)
def test_nagios_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
self.assertThat(processor.entity_graph,
matchers.HasLength(
self._num_total_expected_vertices())
)
spec_list = mock_driver.simple_nagios_alarm_generators(
host_num=1,
events_num=1)
static_events = mock_driver.generate_random_events_list(spec_list)
nagios_event = static_events[0]
nagios_event['resource_name'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
nagios_event['status'] = NagiosTestStatus.CRITICAL
# Action
processor.process_event(nagios_event)
# Test assertions
self.assertThat(processor.entity_graph,
matchers.HasLength(
self._num_total_expected_vertices() + 1)
)
nagios_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE
})
self.assertThat(nagios_vertices, matchers.HasLength(1))
nagios_neighbors = processor.entity_graph.neighbors(
nagios_vertices[0].vertex_id)
self.assertThat(nagios_neighbors, matchers.HasLength(1))
self.assertEqual(NOVA_HOST_DATASOURCE,
nagios_neighbors[0][VProps.VITRAGE_TYPE])
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_DATASOURCE].transform(
event)
# Test assertions
vertex = wrapper.vertex
self._validate_volume_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self.assertThat(neighbors, matchers.HasLength(1))
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_DATASOURCE].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 test_update_transform(self):
LOG.debug('Heat Stack transformer test: transform entity event '
'update')
# Test setup
spec_list = \
mock_sync.simple_stack_generators(stack_num=3,
instance_and_volume_num=7,
snapshot_events=7)
static_events = mock_sync.generate_random_events_list(spec_list)
for event in static_events:
# Test action
wrapper = self.transformers[HEAT_STACK_DATASOURCE].transform(
event)
# Test assertions
vertex = wrapper.vertex
self._validate_stack_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self._validate_neighbors(neighbors, vertex.vertex_id, event)
def test_static_physical_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
transformers = processor.transformer_manager.transformers
transformers[SWITCH] = transformers[STATIC_PHYSICAL_DATASOURCE]
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
spec_list = mock_driver.simple_switch_generators(
switch_num=1,
host_num=1,
snapshot_events=1)
static_events = mock_driver.generate_random_events_list(spec_list)
static_physical_event = static_events[0]
static_physical_event[DSProps.SYNC_TYPE] = SWITCH
static_physical_event['relationships'][0]['name'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
# Action
processor.process_event(static_physical_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 1,
len(processor.entity_graph))
static_physical_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.RESOURCE,
VProps.TYPE: SWITCH
})
self.assertEqual(1, len(static_physical_vertices))
static_physical_neighbors = processor.entity_graph.neighbors(
static_physical_vertices[0].vertex_id)
self.assertEqual(1, len(static_physical_neighbors))
self.assertEqual(NOVA_HOST_DATASOURCE,
static_physical_neighbors[0][VProps.TYPE])
def test_trove_instance_validity(self):
# Setup
processor = self._create_processor_with_graph()
self.assertThat(processor.entity_graph,
matchers.HasLength(
self._num_total_expected_vertices())
)
spec_list = mock_driver.simple_trove_instance_generators(
inst_num=1,
snapshot_events=1)
static_events = mock_driver.generate_random_events_list(spec_list)
trove_instance_event = static_events[0]
trove_instance_event['server_id'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_INSTANCE_DATASOURCE)
# Action
processor.process_event(trove_instance_event)
# Test assertions
self.assertThat(processor.entity_graph,
matchers.HasLength(
self._num_total_expected_vertices() + 1)
)
trove_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_TYPE: TROVE_INSTANCE_DATASOURCE
})
self.assertThat(trove_vertices, matchers.HasLength(1))
trove_neighbors = processor.entity_graph.neighbors(
trove_vertices[0].vertex_id)
self.assertThat(trove_neighbors, matchers.HasLength(1))
self.assertEqual(NOVA_INSTANCE_DATASOURCE,
trove_neighbors[0][VProps.VITRAGE_TYPE])
def test_update_transform(self):
LOG.debug('Consistency transformer test: transform entity event '
'update')
# Test setup
spec_list = mock_sync.simple_consistency_generators(consistency_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[CONSISTENCY_DATASOURCE].transform(
event)
# Test assertions
vertex = wrapper.vertex
self._validate_consistency_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self.assertIsNone(neighbors)
action = wrapper.action
self.assertIn(action, self.actions)
def test_extract_key(self):
LOG.debug('Test get key from nova instance transformer')
# Test setup
spec_list = mock_sync.simple_instance_generators(
host_num=1,
vm_num=1,
snapshot_events=1,
update_events=0
)
instance_events = mock_sync.generate_random_events_list(spec_list)
instance_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE]
for event in instance_events:
# Test action
observed_key = instance_transformer._create_entity_key(event)
# Test assertions
observed_key_fields = observed_key.split(
TransformerBase.KEY_SEPARATOR)
self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0])
self.assertEqual(
NOVA_INSTANCE_DATASOURCE,
observed_key_fields[1]
)
instance_id = tbase.extract_field_value(event, 'id')
self.assertEqual(instance_id, observed_key_fields[2])
key_values = instance_transformer._key_values(
NOVA_INSTANCE_DATASOURCE,
instance_id)
expected_key = tbase.build_key(key_values)
self.assertEqual(expected_key, observed_key)
def test_nagios_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
spec_list = mock_driver.simple_nagios_alarm_generators(
host_num=1,
events_num=1)
static_events = mock_driver.generate_random_events_list(spec_list)
nagios_event = static_events[0]
nagios_event['resource_name'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
nagios_event['status'] = 'critical'
# Action
processor.process_event(nagios_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 1,
len(processor.entity_graph))
nagios_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.ALARM,
VProps.TYPE: NAGIOS_DATASOURCE
})
self.assertEqual(1, len(nagios_vertices))
nagios_neighbors = processor.entity_graph.neighbors(
nagios_vertices[0].vertex_id)
self.assertEqual(1, len(nagios_neighbors))
self.assertEqual(NOVA_HOST_DATASOURCE,
nagios_neighbors[0][VProps.TYPE])
def test_cinder_volume_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
spec_list = mock_driver.simple_volume_generators(
volume_num=1,
instance_num=1,
snapshot_events=1)
static_events = mock_driver.generate_random_events_list(spec_list)
cinder_volume_event = static_events[0]
cinder_volume_event['attachments'][0]['server_id'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_INSTANCE_DATASOURCE)
# Action
processor.process_event(cinder_volume_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 1,
len(processor.entity_graph))
cinder_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.RESOURCE,
VProps.TYPE: CINDER_VOLUME_DATASOURCE
})
self.assertEqual(1, len(cinder_vertices))
cinder_neighbors = processor.entity_graph.neighbors(
cinder_vertices[0].vertex_id)
self.assertEqual(1, len(cinder_neighbors))
self.assertEqual(NOVA_INSTANCE_DATASOURCE,
cinder_neighbors[0][VProps.TYPE])
