def test_parameter_names_containing_sections(self):
c = Configuration()
c.set(self.fullparam, self.value)
self.assertEqual(
self.value, c.get('%s.%s' %
(self.section, self.param)))
def test_contains(self):
c = Configuration()
self.assertFalse(self.section in c)
c.set(self.fullparam, self.value)
self.assertTrue(self.section in c)
def test_subsection_getitem(self):
c = Configuration()
c.set(self.fullparam, self.value)
cs = c.section(self.section)
self.assertEqual(self.value, cs[self.param])
def test_contains(self):
c = Configuration()
self.assertFalse(self.section in c)
c.set(self.fullparam, self.value)
self.assertTrue(self.section in c)
def test_subsection_getitem(self):
c = Configuration()
c.set(self.fullparam, self.value)
cs = c.section(self.section)
self.assertEqual(self.value, cs[self.param])
def test_subsection_setitem(self):
c = Configuration()
cs = c.section(self.section)
cs[self.param] = self.value
self.assertEqual(self.value, c.get(self.fullparam))
def test_type_for_unknown_param(self):
schema = ConfigSchema('test', '1.0', 'ini', [])
c = Configuration(schema)
c.set('param1', '123')
self.assertEqual('123', c.get('param1'))
def test_subsection_setitem(self):
c = Configuration()
cs = c.section(self.section)
cs[self.param] = self.value
self.assertEqual(self.value, c.get(self.fullparam))
def test_validate_returns_none_for_unknown_param(self):
schema = ConfigSchema('test', '1.0', 'ini', [])
c = Configuration(schema)
c.set('param1', '123')
self.assertIsNone(c.validate('param1'))
def test_explicit_default_on_get(self):
c = Configuration()
override_value = '12345'
self.assertEqual(
override_value,
c.get(self.fullparam,
default=override_value))
def test_validate_returns_error_if_valid_is_invalid(self):
schema = ConfigSchema('test', '1.0', 'ini', [
ConfigParameterSchema('param1', type='integer', section='DEFAULT')
])
c = Configuration(schema)
c.set('param1', 'abc')
self.assertTrue(isinstance(c.validate('param1'), InvalidValueError))
def test_validate_returns_none_if_value_is_valid(self):
schema = ConfigSchema('test', '1.0', 'ini', [
ConfigParameterSchema('param1', type='integer', section='DEFAULT')
])
c = Configuration(schema)
c.set('param1', '123')
self.assertIsNone(c.validate('param1'))
def test_getting_typed_param_raw_value(self):
schema = ConfigSchema('test', '1.0', 'ini', [
ConfigParameterSchema('param1', type='integer', section='DEFAULT')
])
c = Configuration(schema)
c.set('param1', '123')
self.assertEqual('123', c.get('param1', raw=True))
def test_typed_param_with_invalid_value_returns_string_value(self):
schema = ConfigSchema('test', '1.0', 'ini', [
ConfigParameterSchema('param1', type='integer', section='DEFAULT')
])
c = Configuration(schema)
c.set('param1', '123a')
self.assertEqual('123a', c.get('param1'))
def test_typed_params(self):
schema = ConfigSchema('test', '1.0', 'ini', [
ConfigParameterSchema('param1', type='integer', section='DEFAULT')
])
c = Configuration(schema)
c.set('param1', '123')
self.assertEqual(123, c.get('param1'))
def config(self):
config = Configuration()
schema = ConfigSchemaRegistry.get_schema('rabbitmq', Version(1000000))
if schema:
for parameter in schema.parameters:
if not parameter.default:
continue
config.set_default(parameter.name, parameter.default)
else:
print("RabbitMQ schema not found")
return config
def config(self):
config = Configuration()
schema = ConfigSchemaRegistry.get_schema('rabbitmq', Version(1000000))
if schema:
for parameter in schema.parameters:
if not parameter.default:
continue
config.set_default(parameter.name, parameter.default)
else:
print("RabbitMQ schema not found")
return config
def test_subsection_contains(self):
c = Configuration()
c.set('section1.param1', '123')
c.set_default('section2.param2', '234')
self.assertTrue('param1' in c.section('section1'))
self.assertTrue('param2' in c.section('section2'))
self.assertFalse('param1' in c.section('section2'))
def test_getting_raw_values(self):
c = Configuration()
c.set('a', '$b')
c.set('b', 'x')
self.assertEqual('$b', c.get('a', raw=True))
def test_subsection_keys(self):
c = Configuration()
c.set_default('%s.param1' % self.section, '123')
c.set('%s.param2' % self.section, '456')
self.assertEqual(['param1', 'param2'],
sorted(c.section(self.section).keys()))
def test_subsection_items(self):
c = Configuration()
c.set('%s.param1' % self.section, 'value1')
c.set_default('%s.param2' % self.section, 'value2')
self.assertEqual([('param1', 'value1'), ('param2', 'value2')],
sorted(c.section(self.section).items()))
def test_template_substitution(self):
c = Configuration()
c.set('a', 'x')
c.set('b', '$a')
c.set('c', '$b')
self.assertEqual('x', c.get('c'))
def test_cycle_template_substitution_resolves_in_empty_string(self):
c = Configuration()
c.set('a', 'a$c')
c.set('b', 'b$a')
c.set('c', 'c$b')
self.assertEqual('cba', c.get('c'))
def _parse_config_resources(self, resources, schema=None):
config = Configuration(schema)
# Apply defaults
if schema:
for parameter in filter(lambda p: p.default, schema.parameters):
if not parameter.section or parameter.section == 'DEFAULT':
config.set_default(parameter.name, parameter.default)
else:
config.set_default(
'%s.%s' %
(parameter.section, parameter.name), parameter.default)
for resource in reversed(resources):
self._parse_config_file(
Mark(resource.path), resource.contents, config, schema,
issue_reporter=resource)
return config
def test_subsection_contains(self):
c = Configuration()
c.set('section1.param1', '123')
c.set_default('section2.param2', '234')
self.assertTrue('param1' in c.section('section1'))
self.assertTrue('param2' in c.section('section2'))
self.assertFalse('param1' in c.section('section2'))
def test_subsection_keys(self):
c = Configuration()
c.set_default('%s.param1' % self.section, '123')
c.set('%s.param2' % self.section, '456')
self.assertEqual(
['param1', 'param2'], sorted(c.section(self.section).keys()))
def test_getting_raw_values(self):
c = Configuration()
c.set('a', '$b')
c.set('b', 'x')
self.assertEqual('$b', c.get('a', raw=True))
def test_cycle_template_substitution_resolves_in_empty_string(self):
c = Configuration()
c.set('a', 'a$c')
c.set('b', 'b$a')
c.set('c', 'c$b')
self.assertEqual('cba', c.get('c'))
def test_template_substitution(self):
c = Configuration()
c.set('a', 'x')
c.set('b', '$a')
c.set('c', '$b')
self.assertEqual('x', c.get('c'))
def test_subsection_items(self):
c = Configuration()
c.set('%s.param1' % self.section, 'value1')
c.set_default('%s.param2' % self.section, 'value2')
self.assertEqual(
[('param1', 'value1'), ('param2', 'value2')],
sorted(c.section(self.section).items()))
def _parse_config_resources(self, resources, schema=None):
config = Configuration()
# Apply defaults
if schema:
for parameter in filter(lambda p: p.default, schema.parameters):
if parameter.section == 'DEFAULT':
config.set_default(parameter.name, parameter.default)
else:
config.set_default(
'%s.%s' % (parameter.section, parameter.name),
parameter.default)
for resource in reversed(resources):
self._parse_config_file(Mark(resource.path),
resource.contents,
config,
schema,
issue_reporter=resource)
return config
def test_returns_section_object_even_if_section_doesnot_exist(self):
c = Configuration()
self.assertIsNotNone(c.section('foo'))
def test_parameter_with_default_section(self):
c = Configuration()
c.set(self.param, self.value)
self.assertEqual(self.value, c.get(self.param))
def test_storage(self):
c = Configuration()
c.set(self.fullparam, self.value)
self.assertEqual(self.value, c.get(self.fullparam))
def test_setitem(self):
c = Configuration()
c[self.fullparam] = self.value
self.assertEqual(self.value, c.get(self.fullparam))
def _parse_config_file(self,
base_mark,
config_contents,
config=Configuration(),
schema=None,
issue_reporter=None):
if issue_reporter:
def report_issue(issue):
issue_reporter.report_issue(issue)
else:
def report_issue(issue):
pass
# Parse config file
config_parser = IniConfigParser()
parsed_config = config_parser.parse('', base_mark, config_contents)
for error in parsed_config.errors:
report_issue(error)
# Validate config parameters and store them
section_name_text_f = lambda s: s.name.text
sections_by_name = groupby(sorted(parsed_config.sections,
key=section_name_text_f),
key=section_name_text_f)
for section_name, sections in sections_by_name:
sections = list(sections)
if len(sections) > 1:
report_issue(
Issue(Issue.INFO, 'Section "%s" appears multiple times' %
section_name))
seen_parameters = set()
for section in sections:
unknown_section = False
if schema:
unknown_section = not schema.has_section(section.name.text)
if unknown_section:
report_issue(
MarkedIssue(Issue.WARNING,
'Unknown section "%s"' % (section_name),
section.start_mark))
continue
for parameter in section.parameters:
parameter_schema = None
if schema:
parameter_schema = schema.get_parameter(
name=parameter.name.text,
section=section.name.text)
if not (parameter_schema or unknown_section):
report_issue(
MarkedIssue(
Issue.WARNING,
'Unknown parameter: section "%s" name "%s"'
% (section_name, parameter.name.text),
parameter.start_mark))
if parameter.name.text in seen_parameters:
report_issue(
MarkedIssue(
Issue.WARNING,
'Parameter "%s" in section "%s" redeclared' %
(parameter.name.text, section_name),
parameter.start_mark))
else:
seen_parameters.add(parameter.name.text)
parameter_fullname = parameter.name.text
if section_name != 'DEFAULT':
parameter_fullname = section_name + \
'.' + parameter_fullname
if parameter_schema:
type_validator = TypeValidatorRegistry.get_validator(
parameter_schema.type)
type_validation_result = type_validator.validate(
parameter.value.text)
if isinstance(type_validation_result, Issue):
type_validation_result.mark = parameter\
.value.start_mark.merge(
type_validation_result.mark)
type_validation_result.message = \
'Property "%s" in section "%s": %s' % (
parameter.name.text, section_name,
type_validation_result.message)
report_issue(type_validation_result)
config.set(parameter_fullname,
parameter.value.text)
else:
value = type_validation_result
config.set(parameter_fullname, value)
# if value == parameter_schema.default:
# report_issue(MarkedIssue(Issue.INFO,
# 'Explicit value equals default: section "%s"
# parameter "%s"' % (section_name,
# parameter.name.text), parameter.start_mark))
if parameter_schema.deprecation_message:
report_issue(
MarkedIssue(
Issue.WARNING,
'Deprecated parameter: section "%s" name '
'"%s". %s' %
(section_name, parameter.name.text,
parameter_schema.deprecation_message),
parameter.start_mark))
else:
config.set(parameter_fullname, parameter.value.text)
return config
def test_getitem(self):
c = Configuration()
c.set(self.fullparam, self.value)
self.assertEqual(self.value, c[self.fullparam])
def test_is_default_returns_false_if_both_values_set(self):
c = Configuration()
c.set_default(self.fullparam, self.default_value)
c.set(self.fullparam, self.value)
self.assertFalse(c.is_default(self.fullparam))
def test_normal_overrides_default(self):
c = Configuration()
c.set(self.fullparam, self.value)
c.set_default(self.fullparam, self.default_value)
self.assertEqual(self.value, c.get(self.fullparam))
def test_empty(self):
c = Configuration()
self.assertIsNone(c.get('section1.param1'))
def test_contains_default(self):
c = Configuration()
c.set_default(self.fullparam, self.default_value)
self.assertTrue(c.contains(self.fullparam))
self.assertFalse(c.contains(self.fullparam, ignoreDefault=True))
def test_keys(self):
c = Configuration()
c.set_default('section1.param1', '123')
c.set('section2.param1', '456')
self.assertEqual(['section1', 'section2'], sorted(c.keys()))
def test_is_default_returns_false_if_param_missing(self):
c = Configuration()
self.assertFalse(c.is_default(self.fullparam))
def test_returns_section_object_even_if_section_doesnot_exist(self):
c = Configuration()
self.assertIsNotNone(c.section('foo'))
def test_parameter_with_default_section(self):
c = Configuration()
c.set(self.param, self.value)
self.assertEqual(self.value, c.get(self.param))
def test_is_default_returns_false_if_both_values_set(self):
c = Configuration()
c.set_default(self.fullparam, self.default_value)
c.set(self.fullparam, self.value)
self.assertFalse(c.is_default(self.fullparam))
def test_is_default_returns_true_if_only_default_value_set(self):
c = Configuration()
c.set_default(self.fullparam, self.default_value)
self.assertTrue(c.is_default(self.fullparam))
def test_parameter_names_containing_sections(self):
c = Configuration()
c.set(self.fullparam, self.value)
self.assertEqual(self.value,
c.get('%s.%s' % (self.section, self.param)))
def test_subsection_set(self):
c = Configuration()
c.section(self.section).set(self.param, self.value)
self.assertEqual(self.value, c.get(self.fullparam))
def test_explicit_default_on_get(self):
c = Configuration()
override_value = '12345'
self.assertEqual(override_value,
c.get(self.fullparam, default=override_value))
def test_normal_overrides_default(self):
c = Configuration()
c.set(self.fullparam, self.value)
c.set_default(self.fullparam, self.default_value)
self.assertEqual(self.value, c.get(self.fullparam))
def test_contains(self):
c = Configuration()
self.assertFalse(c.contains(self.fullparam))
def test_contains(self):
c = Configuration()
self.assertFalse(c.contains(self.fullparam))
def test_contains_normal(self):
c = Configuration()
c.set(self.fullparam, self.value)
self.assertTrue(c.contains(self.fullparam))
self.assertTrue(c.contains(self.fullparam, ignoreDefault=True))
def test_contains_default(self):
c = Configuration()
c.set_default(self.fullparam, self.default_value)
self.assertTrue(c.contains(self.fullparam))
self.assertFalse(c.contains(self.fullparam, ignoreDefault=True))
def test_is_default_returns_true_if_only_default_value_set(self):
c = Configuration()
c.set_default(self.fullparam, self.default_value)
self.assertTrue(c.is_default(self.fullparam))
def test_contains_normal(self):
c = Configuration()
c.set(self.fullparam, self.value)
self.assertTrue(c.contains(self.fullparam))
self.assertTrue(c.contains(self.fullparam, ignoreDefault=True))
def test_subsection_set(self):
c = Configuration()
c.section(self.section).set(self.param, self.value)
self.assertEqual(self.value, c.get(self.fullparam))
def test_is_default_returns_false_if_param_missing(self):
c = Configuration()
self.assertFalse(c.is_default(self.fullparam))
