def test_parse_dict_no_json(self):
"""Test DictOption parse a dict when json is disabled."""
class MySchema(Schema):
foo = self.cls(spec={
'bar': StringOption(),
'baz': IntOption(),
'bla': BoolOption(),
},
parse_json=False)
config = StringIO("""[__main__]
foo = mydict
[mydict]
bar=baz
baz=42
bla=Yes
""")
expected_values = {
'__main__': {
'foo': {
'bar': 'baz',
'baz': 42,
'bla': True
}
}
}
schema = MySchema()
parser = SchemaConfigParser(schema)
parser.readfp(config)
self.assertEqual(parser.values(), expected_values)
def test_parse_dict_json(self):
"""Test DictOption parse a json dict."""
class MySchema(Schema):
foo = self.cls(spec={
'bar': StringOption(),
'baz': IntOption(),
'bla': BoolOption(),
})
config = StringIO(
textwrap.dedent("""
[__main__]
foo = {
"bar": "baz",
"baz": "42",
"bla": "Yes"}
"""))
expected_values = {
'__main__': {
'foo': {
'bar': 'baz',
'baz': 42,
'bla': True
}
}
}
schema = MySchema()
parser = SchemaConfigParser(schema)
parser.readfp(config)
self.assertEqual(parser.values(), expected_values)
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_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_extra_sections_when_lines_dict_with_nested_lines_dicts(self):
"""Test parser.is_valid in dict of nested dict lists."""
class MySchema(Schema):
foo = ListOption(
item=DictOption(
item=ListOption(item=DictOption())))
config = StringIO("""
[__main__]
foo = dict1
dict2
[dict1]
bar = dict3
dict4
[dict2]
baz = dict5
dict6
[dict3]
wham = 1
[dict4]
whaz = 2
[dict5]
whoosh = 3
[dict6]
swoosh = 4
""")
parser = SchemaConfigParser(MySchema())
parser.readfp(config)
parser.parse_all()
self.assertEqual(parser.values(),
{'__main__': {'foo': [
{'bar': [{'wham': '1'}, {'whaz': '2'}]},
{'baz': [{'whoosh': '3'}, {'swoosh': '4'}]}]}})
self.assertTrue(parser.is_valid())
def test_extra_sections_when_lines_dict_with_nested_lines_dicts(self):
"""Test parser.is_valid in dict of nested dict lists."""
class MySchema(Schema):
foo = ListOption(
item=DictOption(
item=ListOption(item=DictOption())))
config = StringIO("""
[__main__]
foo = dict1
dict2
[dict1]
bar = dict3
dict4
[dict2]
baz = dict5
dict6
[dict3]
wham = 1
[dict4]
whaz = 2
[dict5]
whoosh = 3
[dict6]
swoosh = 4
""")
parser = SchemaConfigParser(MySchema())
parser.readfp(config)
parser.parse_all()
self.assertEqual(parser.values(),
{'__main__': {'foo': [
{'bar': [{'wham': '1'}, {'whaz': '2'}]},
{'baz': [{'whoosh': '3'}, {'swoosh': '4'}]}]}})
self.assertTrue(parser.is_valid())
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_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_noschema_section(self):
config = StringIO(
"[__main__]\nfoo=%(bar)s\n[__noschema__]\nbar=hello")
parser = SchemaConfigParser(self.schema)
parser.readfp(config)
parser.parse_all()
self.assertTrue(parser.is_valid())
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_noschema_section(self):
config = StringIO(
"[__main__]\nfoo=%(bar)s\n[__noschema__]\nbar=hello")
parser = SchemaConfigParser(self.schema)
parser.readfp(config)
parser.parse_all()
self.assertTrue(parser.is_valid())
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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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())
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_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_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_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_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_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_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_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_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())
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_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_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_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_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)
