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={'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, action)
# Test setup
spec_list = mock_sync.simple_host_generators(
zone_num=1,
host_num=1,
snapshot_events=1,
snap_vals={'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, action)
def test_extract_key(self):
LOG.debug('Test get key from nova instance transformer')
transformer = get_nova_instance_transformer()
instance_specifications = [
get_instance_entity_spec_list('mock_nova_inst_snapshot.txt', 1),
get_instance_entity_spec_list('mock_nova_inst_update.txt', 1)
]
spec_list = mock_sync.get_mock_generators(instance_specifications)
instance_events = mock_sync.generate_random_events_list(spec_list)
for event in instance_events:
observed_key = transformer.extract_key(event)
observed_key_fields = observed_key.split(nt.KEY_SEPARATOR)
self.assertEqual(nt.ENTITY_TYPE, observed_key_fields[0])
self.assertEqual(nt.INSTANCE_SUB_TYPE, observed_key_fields[1])
event_id = event[transformer.ENTITY_ID_DICT[event['sync_mode']]]
self.assertEqual(event_id, observed_key_fields[2])
expected_key = nt.KEY_SEPARATOR.join(
[nt.ENTITY_TYPE,
nt.INSTANCE_SUB_TYPE,
event_id])
self.assertEqual(expected_key, observed_key)
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 = HostTransformer(self.transformers).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['sync_mode']:
self.assertEqual(EventAction.UPDATE, wrapper.action)
else:
self.assertEqual(EventAction.CREATE, wrapper.action)
def _create_event(self, 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]['sync_mode'] = sync_mode
if event_type is not None:
events_list[0]['event_type'] = event_type
if properties is not None:
for key, value in properties.iteritems():
events_list[0][key] = value
return events_list[0]
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=2,
host_num=3,
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)
# Test assertions
vertex = wrapper.vertex
self._validate_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self._validate_neighbors(neighbors, vertex.vertex_id, event)
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 = InstanceTransformer(self.transformers)
for event in instance_events:
# Test action
observed_key = instance_transformer.extract_key(event)
# Test assertions
observed_key_fields = observed_key.split(
TransformerBase.KEY_SEPARATOR)
self.assertEqual(EntityTypes.RESOURCE, observed_key_fields[0])
self.assertEqual(
InstanceTransformer.INSTANCE_TYPE,
observed_key_fields[1]
)
instance_id = tbase.extract_field_value(
event,
instance_transformer.INSTANCE_ID[event['sync_mode']]
)
self.assertEqual(instance_id, observed_key_fields[2])
key_values = instance_transformer._key_values([instance_id])
expected_key = tbase.build_key(key_values)
self.assertEqual(expected_key, observed_key)
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
instance_transformer = InstanceTransformer(self.transformers)
wrapper = instance_transformer.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)
sync_mode = event['sync_mode']
if sync_mode == SyncMode.INIT_SNAPSHOT:
self.assertEqual(EventAction.CREATE, wrapper.action)
elif sync_mode == SyncMode.SNAPSHOT:
self.assertEqual(EventAction.UPDATE, 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
instance_transformer = InstanceTransformer(self.transformers)
wrapper = instance_transformer.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)
event_type = event['event_type']
if event_type == 'compute.instance.delete.end':
self.assertEqual(EventAction.DELETE, wrapper.action)
elif event_type == 'compute.instance.create.start':
self.assertEqual(EventAction.CREATE, wrapper.action)
else:
self.assertEqual(EventAction.UPDATE, wrapper.action)
