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 _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'