def test_save_no_config_same_files(self):
class MySchema(Schema):
foo = IntOption()
parser = SchemaConfigParser(MySchema())
parser.set('__main__', 'foo', 2)
self.assertRaises(ValueError, parser.save)
def test_parse_lines_of_dict(self):
"""Test ListOption parse a list of dicts."""
class MySchema(Schema):
foo = ListOption(item=DictOption(
spec={
'bar': StringOption(),
'baz': IntOption(),
'bla': BoolOption(),
}))
config = StringIO("""[__main__]
foo = mylist0
mylist1
[mylist0]
bar=baz
baz=42
bla=Yes
[mylist1]
bar=zort
baz=123
bla=0
""")
expected_values = {
'__main__': {'foo': [{'bar': 'baz', 'baz': 42, 'bla': True},
{'bar': 'zort', 'baz': 123, 'bla': False},
]}}
schema = MySchema()
parser = SchemaConfigParser(schema)
parser.readfp(config)
self.assertEqual(parser.values(), expected_values)
def test_save_no_config_same_files(self):
class MySchema(Schema):
foo = IntOption()
parser = SchemaConfigParser(MySchema())
parser.set('__main__', 'foo', 2)
self.assertRaises(ValueError, parser.save)
def test_parse_dict_with_dicts(self):
innerspec = {'bar': StringOption(),
'baz': IntOption(),
'bla': BoolOption(),
}
spec = {'name': StringOption(),
'size': IntOption(),
'options': DictOption(spec=innerspec)}
class MySchema(Schema):
foo = DictOption(spec=spec)
config = StringIO("""[__main__]
foo = outerdict
[outerdict]
options = innerdict
[innerdict]
bar = something
baz = 42
""")
expected_values = {
'__main__': {'foo': {'name': '', 'size': 0,
'options': {'bar': 'something', 'baz': 42,
'bla': False}}}}
schema = MySchema()
parser = SchemaConfigParser(schema)
parser.readfp(config)
self.assertEqual(parser.values(), expected_values)
def test_get_without_environment_var(self):
class MySchema(Schema):
foo = IntOption()
config = StringIO("[__main__]\nfoo=$FOO")
parser = SchemaConfigParser(MySchema())
parser.readfp(config)
self.assertEqual(parser.get('__main__', 'foo'), 0)
def test_locate(self):
config = StringIO("[__main__]\nincludes=%s" % self.name)
parser = SchemaConfigParser(self.schema)
parser.readfp(config, 'my.cfg')
location = parser.locate(option='foo')
expected_location = self.name
self.assertEqual(expected_location, location)
def test_locate(self):
config = StringIO("[__main__]\nincludes=%s" % self.name)
parser = SchemaConfigParser(self.schema)
parser.readfp(config, 'my.cfg')
location = parser.locate(option='foo')
expected_location = self.name
self.assertEqual(expected_location, location)
def test_get_without_environment_var(self):
class MySchema(Schema):
foo = IntOption()
config = StringIO("[__main__]\nfoo=$FOO")
parser = SchemaConfigParser(MySchema())
parser.readfp(config)
self.assertEqual(parser.get('__main__', 'foo'), 0)
def test_option_short_name(self):
"""Test schemaconfigglue support for short option names."""
class MySchema(Schema):
foo = IntOption(short_name='f')
parser = SchemaConfigParser(MySchema())
op, options, args = schemaconfigglue(parser, argv=['-f', '42'])
self.assertEqual(parser.get('__main__', 'foo'), 42)
def setUp(self):
class MySchema(Schema):
class foo(Section):
bar = IntOption()
baz = IntOption(help='The baz option')
self.parser = SchemaConfigParser(MySchema())
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_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_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_option_short_name(self):
"""Test schemaconfigglue support for short option names."""
class MySchema(Schema):
foo = IntOption(short_name='f')
parser = SchemaConfigParser(MySchema())
op, options, args = schemaconfigglue(
parser, argv=['-f', '42'])
self.assertEqual(parser.get('__main__', 'foo'), 42)
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_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_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_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 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_invalid_json(self):
class MySchema(Schema):
foo = self.cls(item=IntOption())
config = BytesIO(b'[__main__]\nfoo = 1, 2, 3')
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_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_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_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_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_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_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_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_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_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_no_json(self):
class MySchema(Schema):
foo = self.cls(item=IntOption(), parse_json=False)
config = BytesIO(b"[__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_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_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_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_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_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_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_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_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_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_remove_dict_duplicates(self):
"""Test ListOption remove_duplicates with DictOption."""
class MyOtherSchema(Schema):
foo = self.cls(item=DictOption(), remove_duplicates=True)
schema = MyOtherSchema()
config = StringIO("[__main__]\nfoo = bla\n bla\n[bla]\nbar = baz")
parser = SchemaConfigParser(schema)
parser.readfp(config)
self.assertEquals({'__main__': {'foo': [{'bar': 'baz'}]}},
parser.values())
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_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_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_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_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_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_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_remove_duplicates(self):
"""Test ListOption with remove_duplicates."""
class MySchema(Schema):
foo = self.cls(item=StringOption(), remove_duplicates=True)
schema = MySchema()
config = StringIO("[__main__]\nfoo = bla\n blah\n bla")
parser = SchemaConfigParser(schema)
parser.readfp(config)
self.assertEquals({'__main__': {'foo': ['bla', 'blah']}},
parser.values())
def test_parse_strict(self):
"""Test DictOption parse in strict mode."""
class MySchema(Schema):
spec = {'bar': IntOption()}
foo = self.cls(spec=spec, strict=True)
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_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_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_parse_invalid_key_in_spec(self):
"""Test DictOption parse with an invalid key in the spec."""
class MySchema(Schema):
foo = self.cls(spec={
'bar': IntOption(),
'baz': IntOption(fatal=True)})
config = StringIO("[__main__]\nfoo=mydict\n[mydict]\nbar=2")
parser = SchemaConfigParser(MySchema())
parser.readfp(config)
self.assertRaises(ValueError, parser.parse_all)
def test_django13_custom_logging_config(self):
config = StringIO(textwrap.dedent("""
[django]
logging_config = foo
"""))
schema = schemas.get('1.3')
parser = SchemaConfigParser(schema())
parser.readfp(config)
value = parser.values()['django']['logging_config']
self.assertEqual(value, 'foo')
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_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())
