def test_not_operator(self):
basic_correct_not_condition_path = \
'%s/templates/not_operator/basic_correct_not_condition.yaml' % \
utils.get_resources_dir()
basic_correct_not_condition_template = \
file_utils.load_yaml_file(basic_correct_not_condition_path)
self._execute_and_assert_with_correct_result(
basic_correct_not_condition_template)
basic_incorrect_not_condition_path = \
'%s/templates/not_operator/basic_incorrect_not_condition.yaml' % \
utils.get_resources_dir()
basic_incorrect_not_condition_template = \
file_utils.load_yaml_file(basic_incorrect_not_condition_path)
self._execute_and_assert_with_fault_result(
basic_incorrect_not_condition_template, 86)
complicated_correct_not_condition_path = \
'%s/templates/not_operator/' \
'complicated_correct_not_condition.yaml' % \
utils.get_resources_dir()
complicated_correct_not_condition_template = \
file_utils.load_yaml_file(complicated_correct_not_condition_path)
self._execute_and_assert_with_correct_result(
complicated_correct_not_condition_template)
complicated_incorrect_not_condition_path = \
'%s/templates/not_operator/' \
'complicated_incorrect_not_condition.yaml' % \
utils.get_resources_dir()
complicated_incorrect_not_condition_template = \
file_utils.load_yaml_file(complicated_incorrect_not_condition_path)
self._execute_and_assert_with_fault_result(
complicated_incorrect_not_condition_template, 86)
def setUpClass(cls):
cls.def_template_dir_path = utils.get_resources_dir() + \
'/templates/def_template_tests'
template_dir_path = '%s/templates/general' % utils.get_resources_dir()
cls.template_yamls = file_utils.load_yaml_files(template_dir_path)
cls.first_template = cls.template_yamls[0]
cls._hide_useless_logging_messages()
def setUp(self):
super(SnmpNotifierTest, self).setUp()
self.cfg_fixture.config(
group='snmp',
alarm_oid_mapping=utils.get_resources_dir() +
'/snmp_notifier/alarm_oid_mapping.yaml',
consumers=utils.get_resources_dir() + '/snmp_notifier/dests.yaml',
oid_tree=utils.get_resources_dir() +
'/snmp_notifier/oid_tree_without_severity_mapping.yaml')
self.snmp_sender = SnmpSender()
def setUp(self):
super(EquivalentScenarioTest, self).setUp()
templates_dir = utils.get_resources_dir() + \
'/templates/equivalent_scenarios/'
equivalences_dir = templates_dir + '/equivalences'
def_templates_dir = utils.get_resources_dir() + \
'/templates/def_template_tests'
self.add_db()
self.add_templates(templates_dir)
self.add_templates(equivalences_dir, TType.EQUIVALENCE)
self.add_templates(def_templates_dir, TType.DEFINITION)
self.scenario_repository = ScenarioRepository()
def setUpClass(cls):
super(TemplateSyntaxValidatorTest, cls).setUpClass()
cls.def_template_dir_path = utils.get_resources_dir() + \
'/templates/def_template_tests'
template_dir_path = '%s/templates/general' % utils.get_resources_dir()
cls.version_dir_path = '%s/templates/version/' \
% utils.get_resources_dir()
cls.template_yamls = file_utils.load_yaml_files(template_dir_path)
cls.bad_template = \
cls._load_template_file(template_dir_path + '/' + BAD_YAML_PATH)
cls.first_template = cls.template_yamls[0]
cls._hide_useless_logging_messages()
def setUpClass(cls):
template_dir_path = '%s/templates/general' % utils.get_resources_dir()
cls.def_templates_tests_path = '%s/templates/def_template_tests/' % \
utils.get_resources_dir()
cls.def_templates_dir_path = cls.def_templates_tests_path +\
'definition_templates'
cls.templates = file_utils.load_yaml_files(template_dir_path)
def_templates_list = file_utils.load_yaml_files(
cls.def_templates_dir_path)
cls.def_templates = utils.get_def_templates_dict_from_list(
def_templates_list)
cls.first_template = cls.templates[0]
cls._hide_useless_logging_messages()
def setUpClass(cls):
template_dir_path = '%s/templates/general' % utils.get_resources_dir()
cls.templates = file_utils.load_yaml_files(template_dir_path)
cls.first_template = cls.templates[0]
cls._hide_useless_logging_messages()
def test_duplicate_entities_in_equivalence(self):
base_dir = utils.get_resources_dir() + '/templates/equivalences_dup'
for directory in os.listdir(base_dir):
self.add_templates(os.path.join(base_dir, directory),
TemplateTypes.EQUIVALENCE)
self.assertRaises(VitrageError, self.equivalence_repository.load,
self._db)
class BaseMock(testtools.TestCase):
"""Base test class for Vitrage API tests."""
PROCESSOR_OPTS = [
cfg.StrOpt('datasources_values_dir',
default=utils.get_resources_dir() + '/datasources_values'),
]
def create_processor_with_graph(self):
conf = cfg.ConfigOpts()
conf.register_opts(self.PROCESSOR_OPTS, group='entity_graph')
events = self._create_mock_events()
processor = proc.Processor(conf, InitializationStatus())
for event in events:
processor.process_event(event)
return processor
@staticmethod
def _create_mock_events():
gen_list = mock_sync.simple_zone_generators(
2,
4,
snapshot_events=2,
snap_vals={'vitrage_datasource_action': 'init_snapshot'})
gen_list += mock_sync.simple_host_generators(
2, 4, 4, snap_vals={'vitrage_datasource_action': 'init_snapshot'})
gen_list += mock_sync.simple_instance_generators(
4,
15,
15,
snap_vals={'vitrage_datasource_action': 'init_snapshot'})
return mock_sync.generate_sequential_events_list(gen_list)
class EquivalentScenarioTest(base.BaseTest):
BASE_DIR = utils.get_resources_dir() + '/templates/equivalent_scenarios/'
OPTS = [
cfg.StrOpt('templates_dir', default=BASE_DIR),
cfg.StrOpt('equivalences_dir', default=BASE_DIR + '/equivalences')
]
@classmethod
def setUpClass(cls):
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.OPTS, group='evaluator')
templates_dir_path = cls.conf.evaluator.templates_dir
cls.template_defs = file_utils.load_yaml_files(templates_dir_path)
cls.scenario_repository = ScenarioRepository(cls.conf)
def test_expansion(self):
entity_scenarios = self.scenario_repository.entity_scenarios
for entity_key, scenarios in entity_scenarios.items():
if ('category', 'ALARM') in entity_key:
# scenarios expanded on the other alarm
self.assertEqual(len(scenarios), 2)
if ('category', 'RESOURCE') in entity_key:
# Scenarios expanded on the two alarms. Each alarm is expanded
# to two equivalent alarms. Thus 2 x 2 = 4 in total
self.assertEqual(len(scenarios), 4)
# each relationship is expand to two. Thus 2 x 2 = 4 in total
relationships = self.scenario_repository.relationship_scenarios.keys()
self.assertEqual(len(relationships), 4)
def test_basic_regex(self):
basic_regex_path = \
REGEX_TEMPLATE_DIR % (utils.get_resources_dir(),
"basic_regex.yaml")
basic_regex_template = \
file_utils.load_yaml_file(basic_regex_path)
self._execute_and_assert_with_correct_result(basic_regex_template)
def _execute_condition_template_with_fault_result(self, template_name,
status_code):
template_path = CONDITION_TEMPLATES_DIR % (utils.get_resources_dir(),
template_name)
template_definition = file_utils.load_yaml_file(template_path, True)
self._execute_and_assert_with_fault_result(template_definition,
status_code)
def test_faulty_regex(self):
faulty_regex_path = \
REGEX_TEMPLATE_DIR % (utils.get_resources_dir(),
"faulty_regex.yaml")
faulty_regex_template = \
file_utils.load_yaml_file(faulty_regex_path)
self._execute_and_assert_with_fault_result(faulty_regex_template, 47)
class TestKapacitorConfig(base.BaseTest):
OPTS = [
cfg.StrOpt(DSOpts.TRANSFORMER,
default='vitrage.datasources.kapacitor.transformer.'
'KapacitorTransformer',
help='Kapacitor data source transformer class path',
required=True),
cfg.StrOpt(DSOpts.DRIVER,
default='vitrage.datasources.kapacitor.driver.'
'KapacitorDriver',
help='Kapacitor driver class path',
required=True),
cfg.StrOpt(DSOpts.CONFIG_FILE,
help='Kapacitor configuration file',
default=utils.get_resources_dir() +
'/kapacitor/kapacitor_conf.yaml'),
]
def setUp(self):
super(TestKapacitorConfig, self).setUp()
self.conf_reregister_opts(self.OPTS, group=KAPACITOR_DATASOURCE)
def test_get_vitrage_resource(self):
"""Test the resource returned after processing a list of mappings
:return:
"""
# Action
kapacitor_conf = KapacitorConfig()
# Test assertions
mapped_resource = kapacitor_conf.get_vitrage_resource(None)
self.assertIsNone(mapped_resource, 'expected None')
mapped_resource = kapacitor_conf.get_vitrage_resource('')
self.assertIsNone(mapped_resource, 'expected None')
mapped_resource = kapacitor_conf.get_vitrage_resource('cloud.compute1')
self.assertIsNotNone(mapped_resource, 'expected Not None')
self.assertEqual(NOVA_HOST_DATASOURCE, mapped_resource[0])
self.assertEqual('compute-1', mapped_resource[1])
mapped_resource = kapacitor_conf.get_vitrage_resource('compute-2')
self.assertIsNotNone(mapped_resource, 'expected Not None')
self.assertEqual(NOVA_HOST_DATASOURCE, mapped_resource[0])
self.assertEqual('compute-2', mapped_resource[1])
mapped_resource = kapacitor_conf.get_vitrage_resource('instance-1')
self.assertIsNotNone(mapped_resource, 'expected Not None')
self.assertEqual(NOVA_INSTANCE_DATASOURCE, mapped_resource[0])
self.assertEqual('instance-1', mapped_resource[1])
@staticmethod
def _assert_equals(mapping1, mapping2):
return mapping1.kapacitor_host_regexp.pattern == \
mapping2.kapacitor_host_regexp.pattern and \
mapping1.resource_type == mapping2.resource_type and \
mapping1.resource_name == mapping2.resource_name
def setUp(self):
super(ScenarioRepositoryTest, self).setUp()
self.add_db()
templates_dir = utils.get_resources_dir() + '/templates/general'
self.add_templates(templates_dir)
templates_dir_path = templates_dir
self.template_defs = file_utils.load_yaml_files(templates_dir_path)
self.scenario_repository = ScenarioRepository()
class EquivalentScenarioTest(base.BaseTest, TestConfiguration):
BASE_DIR = utils.get_resources_dir() + '/templates/equivalent_scenarios/'
OPTS = [
cfg.StrOpt(
'templates_dir',
default=BASE_DIR,
),
cfg.StrOpt(
'def_templates_dir',
default=(utils.get_resources_dir() +
'/templates/def_template_tests'),
),
cfg.StrOpt(
'equivalences_dir',
default=BASE_DIR + '/equivalences',
),
]
@classmethod
def setUpClass(cls):
super(EquivalentScenarioTest, cls).setUpClass()
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.OPTS, group='evaluator')
cls.add_db(cls.conf)
cls.add_templates(cls.conf.evaluator.templates_dir)
cls.add_templates(cls.conf.evaluator.equivalences_dir,
TType.EQUIVALENCE)
cls.add_templates(cls.conf.evaluator.def_templates_dir,
TType.DEFINITION)
cls.scenario_repository = ScenarioRepository(cls.conf)
def test_expansion(self):
entity_scenarios = self.scenario_repository.entity_scenarios
for key, scenarios in entity_scenarios.items():
if (VProps.VITRAGE_CATEGORY, EntityCategory.ALARM) in key:
# scenarios expanded on the other alarm
self.assertThat(scenarios, matchers.HasLength(2))
if (VProps.VITRAGE_CATEGORY, EntityCategory.RESOURCE) in key:
# Scenarios expanded on the two alarms. Each alarm is expanded
# to two equivalent alarms. Thus 2 x 2 = 4 in total
self.assertThat(scenarios, matchers.HasLength(4))
# each relationship is expand to two. Thus 2 x 2 = 4 in total
relationships = self.scenario_repository.relationship_scenarios.keys()
self.assertThat(relationships, matchers.HasLength(4))
class ScenarioRepositoryTest(base.BaseTest):
HOST_HIGH_CPU = 'host_high_cpu_load_to_instance_cpu_suboptimal'
OPTS = [
cfg.StrOpt(
'templates_dir',
default=utils.get_resources_dir() + '/templates/general',
),
]
# noinspection PyPep8Naming
@classmethod
def setUpClass(cls):
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.OPTS, group='evaluator')
templates_dir_path = cls.conf.evaluator.templates_dir
cls.template_defs = file_utils.load_yaml_files(templates_dir_path)
cls.scenario_repository = ScenarioRepository(cls.conf)
def test_template_loader(self):
# Test Action
scenario_repository = ScenarioRepository(self.conf)
# Test assertions
self.assertIsNotNone(scenario_repository)
path, dirs, files = next(os.walk(self.conf.evaluator.templates_dir))
self.assertEqual(len(files), len(scenario_repository.templates))
def test_init_scenario_repository(self):
# Test Setup
valid_template_counter = 0
for template_definition in self.template_defs:
syntax_validation_result = syntax_validation(template_definition)
if syntax_validation_result.is_valid:
valid_template_counter += 1
# Test assertions
self.assertIsNotNone(self.scenario_repository)
scenario_templates = self.scenario_repository.templates
self.assertEqual(valid_template_counter, len(scenario_templates))
def test_get_scenario_by_edge(self):
pass
def test_get_scenario_by_entity(self):
pass
def test_add_template(self):
pass
class EquivalentScenarioTest(base.BaseTest):
BASE_DIR = utils.get_resources_dir() + '/templates/equivalent_scenarios/'
OPTS = [
cfg.StrOpt(
'templates_dir',
default=BASE_DIR,
),
cfg.StrOpt(
'def_templates_dir',
default=(utils.get_resources_dir() +
'/templates/def_template_tests'),
),
cfg.StrOpt(
'equivalences_dir',
default=BASE_DIR + '/equivalences',
),
]
@classmethod
def setUpClass(cls):
super(EquivalentScenarioTest, cls).setUpClass()
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.OPTS, group='evaluator')
templates_dir_path = cls.conf.evaluator.templates_dir
cls.template_defs = file_utils.load_yaml_files(templates_dir_path)
cls.scenario_repository = ScenarioRepository(cls.conf)
def test_expansion(self):
entity_scenarios = self.scenario_repository.entity_scenarios
for key, scenarios in entity_scenarios.items():
if (VProps.VITRAGE_CATEGORY, EntityCategory.ALARM) in key:
# scenarios expanded on the other alarm
self.assertEqual(2, len(scenarios))
if (VProps.VITRAGE_CATEGORY, EntityCategory.RESOURCE) in key:
# Scenarios expanded on the two alarms. Each alarm is expanded
# to two equivalent alarms. Thus 2 x 2 = 4 in total
self.assertEqual(4, len(scenarios))
# each relationship is expand to two. Thus 2 x 2 = 4 in total
relationships = self.scenario_repository.relationship_scenarios.keys()
self.assertEqual(4, len(relationships))
def test_standard_template(self):
template_path = '%s/templates/version/v2/%s' % \
(utils.get_resources_dir(), self.STANDARD_TEMPLATE)
template_definition = file_utils.load_yaml_file(template_path, True)
template_data = get_template_data(template_definition)
self.assertIsNotNone(template_data)
template_type = template_data.template_type
self.assertIsNotNone(template_type, 'v2 template must include a type')
self.assertEqual(TemplateTypes.STANDARD, template_type,
'template_type should be ' + TemplateTypes.STANDARD)
def test_template_loader(self):
# Setup
fp = open(utils.get_resources_dir() + '/nagios/nagios-mock.html')
nagios_html = fp.read()
# Action
nagios_services = NagiosParser().parse(nagios_html)
# Test assertions
self.assertTrue(nagios_services)
self._assert_contains(self.expected_service1, nagios_services)
self._assert_contains(self.expected_service2, nagios_services)
self._assert_contains(self.expected_service3, nagios_services)
def setUp(self):
super(TestDatasourceInfoMapper, self).setUp()
self.cfg_fixture.config(
group='entity_graph',
datasources_values_dir=utils.get_resources_dir() +
'/datasources_values')
self.cfg_fixture.config(group='datasources',
types=[
NAGIOS_DATASOURCE, NOVA_HOST_DATASOURCE,
NOVA_INSTANCE_DATASOURCE,
NOVA_ZONE_DATASOURCE, AODH_DATASOURCE
])
self._load_datasources()
def test_template_loader(self):
# Setup
fp = open(utils.get_resources_dir() + '/nagios/nagios-mock.html')
nagios_html = fp.read()
# Action
nagios_services = NagiosParser().parse(nagios_html)
# Test assertions
self.assertTrue(nagios_services)
self._assert_contains(self.expected_service1, nagios_services)
self._assert_contains(self.expected_service2, nagios_services)
self._assert_contains(self.expected_service3, nagios_services)
def _get_template_single_action(self, template_file):
template_path = '%s/templates/version/%s' % (utils.get_resources_dir(),
template_file)
template_definition = file_utils.load_yaml_file(template_path, True)
template_data = TemplateLoader().load(template_definition)
scenarios = template_data.scenarios
self.assertIsNotNone(scenarios, 'Template should include a scenario')
self.assertThat(scenarios, matchers.HasLength(1),
'Template should include a single scenario')
actions = scenarios[0].actions
self.assertIsNotNone(actions, 'Scenario should include an action')
self.assertThat(actions, matchers.HasLength(1),
'Scenario should include a single action')
return actions[0]
class BaseMock(testtools.TestCase):
"""Base test class for Vitrage API tests."""
PROCESSOR_OPTS = [
cfg.StrOpt('datasources_values_dir',
default=utils.get_resources_dir() + '/datasources_values'),
]
def create_processor_with_graph(self):
conf = cfg.ConfigOpts()
conf.register_opts(self.PROCESSOR_OPTS, group='entity_graph')
events = self._create_mock_events()
e_graph = NXGraph("Entity Graph")
init = VitrageInit(conf)
processor = proc.Processor(conf, init, e_graph)
for event in events:
processor.process_event(event)
return processor
@staticmethod
def _create_mock_events():
gen_list = mock_sync.simple_zone_generators(
2,
4,
snapshot_events=2,
snap_vals={
DatasourceProperties.DATASOURCE_ACTION:
DatasourceAction.INIT_SNAPSHOT
})
gen_list += mock_sync.simple_host_generators(
2,
4,
4,
snap_vals={
DatasourceProperties.DATASOURCE_ACTION:
DatasourceAction.INIT_SNAPSHOT
})
gen_list += mock_sync.simple_instance_generators(
4,
15,
15,
snap_vals={
DatasourceProperties.DATASOURCE_ACTION:
DatasourceAction.INIT_SNAPSHOT
})
return mock_sync.generate_sequential_events_list(gen_list)
def _check_get_condition_common_targets(self, template_name,
valid_targets):
template_path = CONDITION_TEMPLATES_DIR % (utils.get_resources_dir(),
template_name)
template_definition = file_utils.load_yaml_file(template_path, True)
template_data = TemplateLoader().load(template_definition)
definitions_index = template_data.entities.copy()
definitions_index.update(template_data.relationships)
common_targets = get_condition_common_targets(
template_data.scenarios[0].condition, definitions_index,
self.ConditionSymbolResolver())
self.assertIsNotNone(common_targets)
self.assertTrue(common_targets == set(valid_targets))
def test_load_datasources_value_with_errors(self):
# setup
self.cfg_fixture.config(
group='entity_graph',
datasources_values_dir=utils.get_resources_dir() +
'/datasources_values/erroneous_values')
self._load_datasources()
# action
info_mapper = DatasourceInfoMapper()
# test assertions
missing_values = 1
erroneous_values = 1
num_valid_datasources = len(info_mapper.datasources_value_confs) + \
missing_values + erroneous_values
self.assertThat(self.conf.datasources.types,
matchers.HasLength(num_valid_datasources))
def test_basic_template(self):
# Test setup
template_path = "%s/templates/general/%s" % (utils.get_resources_dir(), self.BASIC_TEMPLATE)
template_definition = file_utils.load_yaml_file(template_path, True)
template_data = TemplateData(template_definition)
entities = template_data.entities
relationships = template_data.relationships
scenarios = template_data.scenarios
definitions = template_definition[TFields.DEFINITIONS]
# Assertions
entities_definition = definitions[TFields.ENTITIES]
self._validate_entities(entities, entities_definition)
relate_def = definitions[TFields.RELATIONSHIPS]
self._validate_relationships(relationships, relate_def, entities)
self._validate_scenarios(scenarios, entities)
def _set_conf(self, sub_dir=None):
default_dir = utils.get_resources_dir() + \
'/static_datasources' + (sub_dir if sub_dir else '')
opts = [
cfg.StrOpt(DSOpts.TRANSFORMER,
default='vitrage.datasources.static.transformer.'
'StaticTransformer'),
cfg.StrOpt(DSOpts.DRIVER,
default='vitrage.datasources.static.driver.'
'StaticDriver'),
cfg.IntOpt(DSOpts.CHANGES_INTERVAL,
default=30,
min=30,
help='interval between checking changes in the static '
'datasources'),
cfg.StrOpt('directory', default=default_dir),
]
self.conf_reregister_opts(opts, group=STATIC_DATASOURCE)
def test_basic_template(self):
# Test setup
template_path = '%s/templates/general/%s' % (utils.get_resources_dir(),
self.BASIC_TEMPLATE)
template_definition = file_utils.load_yaml_file(template_path, True)
template = Template(template_definition)
entities = template.entities
relationships = template.relationships
scenarios = template.scenarios
definitions = template_definition[TFields.DEFINITIONS]
# Assertions
entities_definition = definitions[TFields.ENTITIES]
self._validate_entities(entities, entities_definition)
relate_def = definitions[TFields.RELATIONSHIPS]
self._validate_relationships(relationships, relate_def, entities)
self._validate_scenarios(scenarios, entities)
def test_load_datasources_state_with_errors(self):
# setup
entity_graph_opts = [
cfg.StrOpt('datasources_values_dir',
default=utils.get_resources_dir() +
'/datasources_values/erroneous_values'),
]
conf = cfg.ConfigOpts()
conf.register_opts(entity_graph_opts, group='entity_graph')
conf.register_opts(self.DATASOURCES_OPTS, group='datasources')
self._load_datasources(conf)
# action
state_manager = StateManager(conf)
# test assertions
missing_states = 1
erroneous_values = 2
num_valid_datasources = len(state_manager.datasources_state_confs) + \
missing_states + erroneous_values
self.assertEqual(len(conf.datasources.types), num_valid_datasources)
def test_equivalence_template(self):
equivalence_path = '%s/templates/general/equivalences/%s' % (
utils.get_resources_dir(), self.BASIC_TEMPLATE)
equivalence_definition = file_utils.load_yaml_file(
equivalence_path, True)
equivalence_data = EquivalenceData(equivalence_definition)
equivalences = equivalence_data.equivalences
expected = [
frozenset([
frozenset([('category', 'ALARM'), ('type', 'nagios'),
('name', 'host_problem')]),
frozenset([('category', 'ALARM'), ('type', 'zabbix'),
('name', 'host_fail')]),
frozenset([('category', 'ALARM'), ('type', 'vitrage'),
('name', 'host_down')])
]),
]
self.assertEqual(expected, equivalences)
def test_load_datasources_state_with_errors(self):
# setup
entity_graph_opts = [
cfg.StrOpt('datasources_values_dir',
default=utils.get_resources_dir() +
'/datasources_values/erroneous_values'),
]
conf = cfg.ConfigOpts()
conf.register_opts(entity_graph_opts, group='entity_graph')
conf.register_opts(self.DATASOURCES_OPTS, group='datasources')
self._load_datasources(conf)
# action
state_manager = DatasourceInfoMapper(conf)
# test assertions
missing_states = 1
erroneous_values = 1
num_valid_datasources = len(state_manager.datasources_state_confs) + \
missing_states + erroneous_values
self.assertEqual(num_valid_datasources, len(conf.datasources.types))
def test_load_datasources_value_with_errors(self):
# setup
entity_graph_opts = [
cfg.StrOpt('datasources_values_dir',
default=utils.get_resources_dir() +
'/datasources_values/erroneous_values'),
]
conf = cfg.ConfigOpts()
conf.register_opts(entity_graph_opts, group='entity_graph')
conf.register_opts(self.DATASOURCES_OPTS, group='datasources')
self._load_datasources(conf)
# action
info_mapper = DatasourceInfoMapper(conf)
# test assertions
missing_values = 1
erroneous_values = 1
num_valid_datasources = len(info_mapper.datasources_value_confs) + \
missing_values + erroneous_values
self.assertThat(conf.datasources.types,
matchers.HasLength(num_valid_datasources))
def test_equivalence_template(self):
equivalence_path = '%s/templates/general/equivalences/%s' % (
utils.get_resources_dir(),
self.BASIC_TEMPLATE)
equivalence_definition = file_utils.load_yaml_file(equivalence_path,
True)
equivalences = EquivalenceLoader(equivalence_definition).equivalences
expected = [
frozenset([
frozenset([(VProps.VITRAGE_CATEGORY, EntityCategory.ALARM),
(VProps.VITRAGE_TYPE, NAGIOS_DATASOURCE),
(VProps.NAME, 'host_problem')]),
frozenset([(VProps.VITRAGE_CATEGORY, EntityCategory.ALARM),
(VProps.VITRAGE_TYPE, ZABBIX_DATASOURCE),
(VProps.NAME, 'host_fail')]),
frozenset([(VProps.VITRAGE_CATEGORY, EntityCategory.ALARM),
(VProps.VITRAGE_TYPE, VITRAGE_DATASOURCE),
(VProps.NAME, 'host_down')])
]),
]
self.assertEqual(expected, equivalences)
def setUpClass(cls):
template_dir_path = '%s/templates/general' % utils.get_resources_dir()
cls.templates = file_utils.load_yaml_files(template_dir_path)
cls.first_template = cls.templates[0]
DYNAMIC_INFO_FKEY = 'filename'
DYNAMIC_INFO_FPATH = 'filepath'
STATIC_INFO_FKEY = 'static_filename'
NAME_KEY = 'name'
MAPPING_KEY = 'mapping'
EXTERNAL_INFO_KEY = 'external'
NUM_EVENTS = '#events'
GENERATOR = 'generator'
# specification files for input types
# Mock driver specs
MOCK_DRIVER_PATH = '%s/mock_configurations/driver' % \
utils.get_resources_dir()
DRIVER_HOST_SNAPSHOT_D = 'driver_host_snapshot_dynamic.json'
DRIVER_INST_SNAPSHOT_D = 'driver_inst_snapshot_dynamic.json'
DRIVER_INST_SNAPSHOT_S = 'driver_inst_snapshot_static.json'
DRIVER_INST_UPDATE_D = 'driver_inst_update_dynamic.json'
DRIVER_NAGIOS_SNAPSHOT_D = 'driver_nagios_snapshot_dynamic.json'
DRIVER_NAGIOS_SNAPSHOT_S = 'driver_nagios_snapshot_static.json'
DRIVER_ZABBIX_SNAPSHOT_D = 'driver_zabbix_snapshot_dynamic.json'
DRIVER_SWITCH_SNAPSHOT_D = 'driver_switch_snapshot_dynamic.json'
DRIVER_VOLUME_UPDATE_D = 'driver_volume_update_dynamic.json'
DRIVER_VOLUME_SNAPSHOT_D = 'driver_volume_snapshot_dynamic.json'
DRIVER_STACK_UPDATE_D = 'driver_stack_update_dynamic.json'
DRIVER_STACK_SNAPSHOT_D = 'driver_stack_snapshot_dynamic.json'
DRIVER_CONSISTENCY_UPDATE_D = 'driver_consistency_update_dynamic.json'
DRIVER_ZONE_SNAPSHOT_D = 'driver_zone_snapshot_dynamic.json'
