def test_parse_no_strict_extra_args(self): class MySchema(Schema): foo = self.cls() config = StringIO("[__main__]\nfoo=mydict\n[mydict]\nbar=2") expected_values = {'__main__': {'foo': {'bar': '2'}}} parser = SchemaConfigParser(MySchema()) parser.readfp(config) self.assertEqual(parser.values(), expected_values)
def test_get_with_environment_var(self, mock_os): mock_os.environ = {'FOO': '42'} class MySchema(Schema): foo = IntOption() config = StringIO("[__main__]\nfoo=$FOO") parser = SchemaConfigParser(MySchema()) parser.readfp(config) self.assertEqual(parser.get('__main__', 'foo'), 42)
def test_parse_non_list_json(self): class MySchema(Schema): foo = self.cls(item=IntOption()) config = StringIO('[__main__]\nfoo = {"foo": "bar"}') schema = MySchema() parser = SchemaConfigParser(schema) parser.readfp(config) self.assertRaises(ValueError, parser.values)
def test_parse_no_json_with_json(self): class MySchema(Schema): foo = self.cls(item=IntOption(), parse_json=False) config = StringIO("[__main__]\nfoo = [42, 43, 44]") schema = MySchema() parser = SchemaConfigParser(schema) parser.readfp(config) self.assertRaises(ValueError, parser.values)
def test_interpolate_environment_default_loop(self, mock_compile, mock_os): mock_os.environ = {'FOO': 'foo'} parser = SchemaConfigParser(Schema()) mock_match = MagicMock() mock_match.group.return_value = "FOO" mock_compile.return_value.search.return_value = mock_match result = parser.interpolate_environment("${FOO:-bar}") # should be uninterpolated result self.assertEqual(result, '${FOO:-bar}')
def test_basic_interpolate(self): class MySchema(Schema): foo = StringOption() bar = BoolOption() config = StringIO('[__main__]\nbar=%(foo)s\nfoo=True') parser = SchemaConfigParser(MySchema()) parser.readfp(config, 'my.cfg') self.assertEquals({'__main__': {'foo': 'True', 'bar': True}}, parser.values())
def test_parser_set_with_encoding(self): """Test schemaconfigglue override an option with a non-ascii value.""" class MySchema(Schema): foo = StringOption() parser = SchemaConfigParser(MySchema()) op, options, args = schemaconfigglue(parser, argv=['--foo', 'fóobâr']) self.assertEqual(parser.get('__main__', 'foo', parse=False), 'fóobâr') self.assertEqual(parser.get('__main__', 'foo'), 'fóobâr')
def ini2schema(fd, p=None): """ Turn a fd that refers to a INI-style schema definition into a SchemaConfigParser object @param fd: file-like object to read the schema from @param p: a parser to use. If not set, uses AttributedConfigParser """ if p is None: p = AttributedConfigParser() p.readfp(fd) p.parse_all() parser2option = {'unicode': StringOption, 'int': IntOption, 'bool': BoolOption, 'lines': ListOption} class MySchema(Schema): pass for section_name in p.sections(): if section_name == '__main__': section = MySchema else: section = Section(name=section_name) setattr(MySchema, section_name, section) for option_name in p.options(section_name): option = p.get(section_name, option_name) parser = option.attrs.pop('parser', 'unicode') parser_args = option.attrs.pop('parser.args', '').split() parser_fun = getattr(parsers, parser, None) if parser_fun is None: parser_fun = getattr(__builtin__, parser, None) if parser_fun is None: parser_fun = lambda x: x attrs = {'name': option_name} option_help = option.attrs.pop('help', None) if option_help is not None: attrs['help'] = option_help if not option.is_empty: attrs['default'] = parser_fun(option.value, *parser_args) option_action = option.attrs.pop('action', None) if option_action is not None: attrs['action'] = option_action klass = parser2option.get(parser, StringOption) if parser == 'lines': instance = klass(item=StringOption(), **attrs) else: instance = klass(**attrs) setattr(section, option_name, instance) return SchemaConfigParser(MySchema())
def test_time_zone_is_null(self): config = StringIO(textwrap.dedent(""" [django] time_zone = None """)) parser = SchemaConfigParser(BaseDjangoSchema()) parser.readfp(config) value = parser.values()['django']['time_zone'] self.assertEqual(value, None)
def test_get_django_settings(self): class MySchema(Schema): foo = IntOption() bar = DictOption(spec={'baz': IntOption(), 'BAZ': IntOption()}) expected = {'FOO': 0, 'BAR': {'baz': 0, 'BAZ': 0}} parser = SchemaConfigParser(MySchema()) result = get_django_settings(parser) self.assertEqual(result, expected)
def test_parse_strict_extra_vars(self): """Test DictOption parse in strict mode with extra values.""" class MySchema(Schema): spec = {'bar': IntOption()} foo = self.cls(spec=spec, strict=True) config = StringIO("[__main__]\nfoo=mydict\n[mydict]\nbar=2\nbaz=3") parser = SchemaConfigParser(MySchema()) parser.readfp(config) self.assertRaises(ValueError, parser.parse_all)
def test_parse_json(self): class MySchema(Schema): foo = self.cls(item=IntOption()) config = StringIO("[__main__]\nfoo = [42, 43, 44]") expected_values = {'__main__': {'foo': [42, 43, 44]}} schema = MySchema() parser = SchemaConfigParser(schema) parser.readfp(config) self.assertEqual(parser.values(), expected_values)
def test_parse_no_length(self): """Test TupleOption parse without length.""" class MySchema(Schema): foo = self.cls() config = StringIO('[__main__]\nfoo=1,2,3,4') expected_values = {'__main__': {'foo': ('1', '2', '3', '4')}} parser = SchemaConfigParser(MySchema()) parser.readfp(config) self.assertEqual(parser.values(), expected_values)
def test_parse_invalid_key_in_parsed(self): """Test DictOption parse with an invalid key in the config.""" class MySchema(Schema): foo = self.cls(spec={'bar': IntOption()}) config = StringIO("[__main__]\nfoo=mydict\n[mydict]\nbaz=2") expected_values = {'__main__': {'foo': {'bar': 0, 'baz': '2'}}} parser = SchemaConfigParser(MySchema()) parser.readfp(config) self.assertEqual(parser.values(), expected_values)
def test_parse_no_strict_missing_args(self): """Test DictOption parse a missing key in non-strict mode.""" class MySchema(Schema): foo = self.cls(spec={'bar': IntOption()}) config = StringIO("[__main__]\nfoo=mydict\n[mydict]") expected_values = {'__main__': {'foo': {'bar': 0}}} parser = SchemaConfigParser(MySchema()) parser.readfp(config) self.assertEqual(parser.values(), expected_values)
def test_fatal_option_with_config(self): class MySchema(Schema): foo = IntOption(fatal=True) config = StringIO("[__main__]\nfoo=1") parser = SchemaConfigParser(MySchema()) parser.readfp(config) op, options, args = schemaconfigglue(parser) self.assertEqual(parser.values(), {'__main__': {'foo': 1}})
def test_read_ioerror(self, mock_open, mock_warn): mock_open.side_effect = IOError parser = SchemaConfigParser(self.schema) read_ok = parser.read(self.name) self.assertEqual(read_ok, []) self.assertEqual(mock_warn.call_args_list, [(("File {0} could not be read. Skipping.".format(self.name),), {})])
def test_basic_is_valid_with_report(self): """Test basic validation with error reporting.""" class MySchema(Schema): foo = IntOption() config = StringIO("[__main__]\nfoo=5") expected = (True, []) parser = SchemaConfigParser(MySchema()) parser.readfp(config) valid, errors = parser.is_valid(report=True) self.assertEqual((valid, errors), expected)
def test_basic_is_not_valid(self): """Test invalid config without error reporting.""" class MySchema(Schema): foo = IntOption() schema = MySchema() config = StringIO("[__main__]\nfoo = 5\nbar = 6") parser = SchemaConfigParser(schema) parser.readfp(config) self.assertFalse(parser.is_valid())
def test_parse_int_lines(self): """Test ListOption parse a list of integers.""" class MySchema(Schema): foo = self.cls(item=IntOption()) config = StringIO("[__main__]\nfoo = 42\n 43\n 44") expected_values = {'__main__': {'foo': [42, 43, 44]}} schema = MySchema() parser = SchemaConfigParser(schema) parser.readfp(config) self.assertEqual(parser.values(), expected_values)
def test_get_interpolation_keys_bool(self): """Test get_interpolation_keys for a boolean.""" class MySchema(Schema): foo = BoolOption() config = StringIO("[__main__]\nfoo=%(bar)s") expected = ('%(bar)s', set(['bar'])) parser = SchemaConfigParser(MySchema()) parser.readfp(config) result = parser._get_interpolation_keys('__main__', 'foo') self.assertEqual(result, expected)
def test_get_with_raw_value(self): """Test get using a raw value.""" class MySchema(Schema): foo = StringOption(raw=True) config = StringIO('[__main__]\nfoo=blah%(asd)##$@@dddf2kjhkjs') expected_value = 'blah%(asd)##$@@dddf2kjhkjs' parser = SchemaConfigParser(MySchema()) parser.readfp(config) value = parser.get('__main__', 'foo') self.assertEqual(value, expected_value)
def test_interpolate_value_invalid_key(self): """Test interpolate_value with an invalid key.""" class MySchema(Schema): foo = TupleOption(2) config = StringIO("[other]\nbar=4\n[__main__]\nfoo=%(bar)s,%(bar)s") expected_value = None parser = SchemaConfigParser(MySchema()) parser.readfp(config) value = parser._interpolate_value('__main__', 'foo') self.assertEqual(value, expected_value)
def test_get_interpolation_keys_lines(self): """Test get_interpolation_keys for a list.""" class MySchema(Schema): foo = ListOption(item=StringOption()) config = StringIO("[__main__]\nfoo=%(bar)s\n %(baz)s") expected = ('%(bar)s\n%(baz)s', set(['bar', 'baz'])) parser = SchemaConfigParser(MySchema()) parser.readfp(config) result = parser._get_interpolation_keys('__main__', 'foo') self.assertEqual(result, expected)
def test_parse_bool_lines(self): """Test ListOption parse a list of booleans.""" class MySchema(Schema): foo = self.cls(item=BoolOption()) schema = MySchema() config = StringIO("[__main__]\nfoo = tRuE\n No\n 0\n 1") expected_values = {'__main__': {'foo': [True, False, False, True]}} parser = SchemaConfigParser(schema) parser.readfp(config) self.assertEqual(expected_values, parser.values())
def test_missing_nonfatal_options(self): """Test parser.is_valid when missing non-fatal options.""" class MySchema(Schema): foo = IntOption() bar = IntOption(fatal=True) config = StringIO("[__main__]\nbar=2") parser = SchemaConfigParser(MySchema()) parser.readfp(config) self.assertTrue(parser.is_valid())
def test_parse_bool_empty_lines(self): """Test ListOption parse an empty list of booleans.""" class MySchema(Schema): foo = self.cls(item=BoolOption()) schema = MySchema() config = StringIO("[__main__]\nfoo =") parser = SchemaConfigParser(schema) parser.readfp(config) expected_values = {'__main__': {'foo': []}} self.assertEqual(expected_values, parser.values())
def test_parse_strict_missing_vars(self): """Test DictOption parse in strict mode with missing values.""" class MySchema(Schema): spec = {'bar': IntOption(), 'baz': IntOption()} foo = self.cls(spec=spec, strict=True) config = StringIO("[__main__]\nfoo=mydict\n[mydict]\nbar=2") expected_values = {'__main__': {'foo': {'bar': 2, 'baz': 0}}} parser = SchemaConfigParser(MySchema()) parser.readfp(config) self.assertEqual(parser.values(), expected_values)
def test_extra_sections_dict_default_value(self): """Test parse dict with default value.""" class MySchema(Schema): foo = DictOption(spec={ 'bar': IntOption(), 'baz': BoolOption()}) parser = SchemaConfigParser(MySchema()) self.assertEqual(parser.get('__main__', 'foo'), {'bar': 0, 'baz': False}) self.assertEqual(parser.extra_sections, set([]))
def test_extra_sections(self): """Test parser.is_valid with extra sections.""" class MySchema(Schema): foo = DictOption(spec={'bar': IntOption()}) config = StringIO("[__main__]\nfoo=mydict\n[mydict]\nbar=1") parser = SchemaConfigParser(MySchema()) parser.readfp(config) parser.parse_all() self.assertTrue(parser.is_valid())