示例#1
0
    def test_parse_bool(self):
        """Test BoolOption parse a boolean value."""
        class MySchema(Schema):
            foo = self.cls()

        config = StringIO("[__main__]\nfoo = Yes")
        expected_values = {'__main__': {'foo': True}}
        schema = MySchema()
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertEqual(parser.values(), expected_values)

        config = StringIO("[__main__]\nfoo = tRuE")
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertEqual(parser.values(), expected_values)

        config = StringIO("[__main__]\nfoo =")
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertRaises(ValueError, parser.values)

        config = StringIO("[__main__]\nfoo = bla")
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertRaises(ValueError, parser.values)
    def test_multi_file_dict_list_config(self):
        """Test parsing a list of dicts option spanning multiple files."""
        class MySchema(Schema):
            foo = ListOption(
                item=DictOption(spec={
                    'bar': IntOption(),
                    'baz': IntOption(),
                }, strict=True))

        config1 = StringIO('[__main__]\nfoo=mydict\n[mydict]\nbar=1\nbaz=1')
        expected_values = {'__main__': {'foo': [{'bar': 1, 'baz': 1}]}}

        parser = SchemaConfigParser(MySchema())
        parser.readfp(config1)
        self.assertEqual(parser.values(), expected_values)

        # override used dictionaries
        config2 = StringIO('[__main__]\nfoo=otherdict\n[otherdict]\nbar=2')
        expected_values = {'__main__': {'foo': [{'bar': 2, 'baz': 0}]}}
        parser.readfp(config2)
        self.assertEqual(parser.values(), expected_values)

        # override existing dictionaries
        config3 = StringIO('[otherdict]\nbaz=3')
        expected_values = {'__main__': {'foo': [{'bar': 2, 'baz': 3}]}}
        parser.readfp(config3)
        self.assertEqual(parser.values(), expected_values)

        # reuse existing dict
        config4 = StringIO('[__main__]\nfoo=mydict\n    otherdict')
        expected_values = {'__main__': {'foo': [{'bar': 1, 'baz': 1},
                                               {'bar': 2, 'baz': 3}]}}
        parser.readfp(config4)
        self.assertEqual(parser.values(), expected_values)
示例#3
0
    def test_multi_file_dict_list_config(self):
        """Test parsing a list of dicts option spanning multiple files."""
        class MySchema(Schema):
            foo = ListOption(
                item=DictOption(spec={
                    'bar': IntOption(),
                    'baz': IntOption(),
                }, strict=True))

        config1 = StringIO('[__main__]\nfoo=mydict\n[mydict]\nbar=1\nbaz=1')
        expected_values = {'__main__': {'foo': [{'bar': 1, 'baz': 1}]}}

        parser = SchemaConfigParser(MySchema())
        parser.readfp(config1)
        self.assertEqual(parser.values(), expected_values)

        # override used dictionaries
        config2 = StringIO('[__main__]\nfoo=otherdict\n[otherdict]\nbar=2')
        expected_values = {'__main__': {'foo': [{'bar': 2, 'baz': 0}]}}
        parser.readfp(config2)
        self.assertEqual(parser.values(), expected_values)

        # override existing dictionaries
        config3 = StringIO('[otherdict]\nbaz=3')
        expected_values = {'__main__': {'foo': [{'bar': 2, 'baz': 3}]}}
        parser.readfp(config3)
        self.assertEqual(parser.values(), expected_values)

        # reuse existing dict
        config4 = StringIO('[__main__]\nfoo=mydict\n    otherdict')
        expected_values = {'__main__': {'foo': [{'bar': 1, 'baz': 1},
                                               {'bar': 2, 'baz': 3}]}}
        parser.readfp(config4)
        self.assertEqual(parser.values(), expected_values)
示例#4
0
class TestListOfTuples(unittest.TestCase):
    def setUp(self):
        class MySchema(Schema):
            foo = ListOption(item=TupleOption(length=3))

        schema = MySchema()
        self.parser = SchemaConfigParser(schema)

    def test_parse_list_of_tuples(self):
        config = StringIO('[__main__]\nfoo = a, b, c\n      d, e, f')
        expected_values = {
            '__main__': {
                'foo': [('a', 'b', 'c'), ('d', 'e', 'f')]
            }
        }
        self.parser.readfp(config)
        self.assertEqual(self.parser.values(), expected_values)

    def test_parse_wrong_tuple_size(self):
        config = StringIO('[__main__]\nfoo = a, b, c\n      d, e')
        self.parser.readfp(config)
        self.assertRaises(ValueError, self.parser.values)

    def test_parse_empty_tuple(self):
        config = StringIO('[__main__]\nfoo=()')
        expected_values = {'__main__': {'foo': [()]}}
        self.parser.readfp(config)
        self.assertEqual(self.parser.values(), expected_values)
示例#5
0
    def test_parse_bool(self):
        """Test BoolOption parse a boolean value."""
        class MySchema(Schema):
            foo = self.cls()

        config = StringIO("[__main__]\nfoo = Yes")
        expected_values = {'__main__': {'foo': True}}
        schema = MySchema()
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertEqual(parser.values(), expected_values)

        config = StringIO("[__main__]\nfoo = tRuE")
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertEqual(parser.values(), expected_values)

        config = StringIO("[__main__]\nfoo =")
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertRaises(ValueError, parser.values)

        config = StringIO("[__main__]\nfoo = bla")
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertRaises(ValueError, parser.values)
示例#6
0
class TestListOfTuples(unittest.TestCase):
    def setUp(self):
        class MySchema(Schema):
            foo = ListOption(item=TupleOption(length=3))

        schema = MySchema()
        self.parser = SchemaConfigParser(schema)

    def test_parse_list_of_tuples(self):
        config = StringIO('[__main__]\nfoo = a, b, c\n      d, e, f')
        expected_values = {
            '__main__': {'foo': [('a', 'b', 'c'), ('d', 'e', 'f')]}}
        self.parser.readfp(config)
        self.assertEqual(self.parser.values(), expected_values)

    def test_parse_wrong_tuple_size(self):
        config = StringIO('[__main__]\nfoo = a, b, c\n      d, e')
        self.parser.readfp(config)
        self.assertRaises(ValueError, self.parser.values)

    def test_parse_empty_tuple(self):
        config = StringIO('[__main__]\nfoo=()')
        expected_values = {'__main__': {'foo': [()]}}
        self.parser.readfp(config)
        self.assertEqual(self.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())
示例#8
0
    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)
示例#9
0
    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)
示例#10
0
    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)
示例#11
0
    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())
示例#12
0
    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)
示例#13
0
    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_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())
示例#15
0
 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())
示例#16
0
    def test_ambiguous_option(self):
        """Test schemaconfigglue when an ambiguous option is specified."""
        class MySchema(Schema):
            class foo(Section):
                baz = IntOption()

            class bar(Section):
                baz = IntOption()

        config = StringIO("[foo]\nbaz=1")
        parser = SchemaConfigParser(MySchema())
        parser.readfp(config)
        self.assertEqual(parser.values('foo'), {'baz': 1})
        self.assertEqual(parser.values('bar'), {'baz': 0})

        op, options, args = schemaconfigglue(parser, argv=['--bar_baz', '2'])
        self.assertEqual(parser.values('foo'), {'baz': 1})
        self.assertEqual(parser.values('bar'), {'baz': 2})
示例#17
0
    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)
示例#18
0
    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)
示例#19
0
    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)
示例#20
0
    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)
示例#21
0
    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)
示例#22
0
    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)
示例#23
0
    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)
示例#24
0
    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)
示例#25
0
    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)
示例#26
0
    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_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_ambiguous_option(self):
        """Test schemaconfigglue when an ambiguous option is specified."""
        class MySchema(Schema):
            class foo(Section):
                baz = IntOption()

            class bar(Section):
                baz = IntOption()

        config = StringIO("[foo]\nbaz=1")
        parser = SchemaConfigParser(MySchema())
        parser.readfp(config)
        self.assertEqual(parser.values('foo'), {'baz': 1})
        self.assertEqual(parser.values('bar'), {'baz': 0})

        op, options, args = schemaconfigglue(
            parser, argv=['--bar_baz', '2'])
        self.assertEqual(parser.values('foo'), {'baz': 1})
        self.assertEqual(parser.values('bar'), {'baz': 2})
示例#29
0
    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)
示例#30
0
    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)
示例#31
0
    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_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')
示例#33
0
    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())
示例#34
0
    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())
示例#35
0
    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_glue_json_dict(self):
        class MySchema(Schema):
            foo = DictOption()

        parser = SchemaConfigParser(MySchema())
        op, options, args = schemaconfigglue(parser,
            argv=['--foo', '{"bar": "baz"}'])

        self.assertEqual(options, {'foo': '{"bar": "baz"}'})
        self.assertEqual(parser.values(),
            {'__main__': {'foo': {'bar': 'baz'}}})
示例#37
0
    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)
示例#38
0
    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())
示例#39
0
    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)
示例#40
0
    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())
示例#41
0
    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())
示例#42
0
    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_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')
示例#44
0
    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())
示例#45
0
    def test_interpolate_environment_in_config(self, mock_os):
        mock_os.environ = {'PYTHONPATH': 'foo', 'PATH': 'bar'}

        class MySchema(Schema):
            pythonpath = StringOption()
            path = StringOption()

        config = StringIO("[__main__]\npythonpath=${PYTHONPATH}\npath=$PATH")
        parser = SchemaConfigParser(MySchema())
        parser.readfp(config)
        self.assertEqual(parser.values('__main__'),
            {'pythonpath': 'foo', 'path': 'bar'})
示例#46
0
    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())
示例#47
0
    def test_get_django_settings_encoding(self):
        class MySchema(Schema):
            foo = StringOption()

        expected = {'FOO': u'€'.encode(SETTINGS_ENCODING)}

        config = StringIO(u'[__main__]\nfoo=€'.encode(CONFIG_FILE_ENCODING))
        parser = SchemaConfigParser(MySchema())
        parser.readfp(config)
        self.assertEqual(parser.values('__main__'), {'foo': u'€'})
        result = get_django_settings(parser)
        self.assertEqual(result, expected)
    def test_interpolate_environment_in_config(self, mock_os):
        mock_os.environ = {'PYTHONPATH': 'foo', 'PATH': 'bar'}

        class MySchema(Schema):
            pythonpath = StringOption()
            path = StringOption()

        config = StringIO("[__main__]\npythonpath=${PYTHONPATH}\npath=$PATH")
        parser = SchemaConfigParser(MySchema())
        parser.readfp(config)
        self.assertEqual(parser.values('__main__'),
            {'pythonpath': 'foo', 'path': 'bar'})
    def test_get_django_settings_encoding(self):
        class MySchema(Schema):
            foo = StringOption()

        expected = {'FOO': u'€'.encode(SETTINGS_ENCODING)}

        config = StringIO(u'[__main__]\nfoo=€'.encode(CONFIG_FILE_ENCODING))
        parser = SchemaConfigParser(MySchema())
        parser.readfp(config)
        self.assertEqual(parser.values('__main__'), {'foo': u'€'})
        result = get_django_settings(parser)
        self.assertEqual(result, expected)
示例#50
0
    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_multi_file_dict_config(self):
        """Test parsing a dict option spanning multiple files."""
        class MySchema(Schema):
            foo = DictOption(spec={
                'bar': IntOption(),
                'baz': IntOption(),
            }, strict=True)
        config1 = StringIO('[__main__]\nfoo=mydict\n[mydict]\nbar=1\nbaz=1')
        config2 = StringIO('[mydict]\nbaz=2')
        expected_values = {'__main__': {'foo': {'bar': 1, 'baz': 2}}}

        parser = SchemaConfigParser(MySchema())
        parser.readfp(config1)
        parser.readfp(config2)
        self.assertEqual(parser.values(), expected_values)
示例#52
0
    def test_default_values(self):
        """Test parser reads default option values."""
        class MySchema(Schema):
            foo = BoolOption(default=True)

            class bar(Section):
                baz = IntOption()
                bla = StringOption(default='hello')

        schema = MySchema()
        config = StringIO("[bar]\nbaz=123")
        expected_values = {'__main__': {'foo': True},
                           'bar': {'baz': 123, 'bla': 'hello'}}
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertEquals(expected_values, parser.values())

        config = StringIO("[bar]\nbla=123")
        expected = {
            '__main__': {'foo': True},
            'bar': {'baz': 0, 'bla': '123'}}
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertEquals(expected, parser.values())
示例#53
0
    def test_multi_file_dict_config(self):
        """Test parsing a dict option spanning multiple files."""
        class MySchema(Schema):
            foo = DictOption(spec={
                'bar': IntOption(),
                'baz': IntOption(),
            }, strict=True)
        config1 = StringIO('[__main__]\nfoo=mydict\n[mydict]\nbar=1\nbaz=1')
        config2 = StringIO('[mydict]\nbaz=2')
        expected_values = {'__main__': {'foo': {'bar': 1, 'baz': 2}}}

        parser = SchemaConfigParser(MySchema())
        parser.readfp(config1)
        parser.readfp(config2)
        self.assertEqual(parser.values(), expected_values)
示例#54
0
    def test_glue_json_dict(self):
        class MySchema(Schema):
            foo = DictOption()

        parser = SchemaConfigParser(MySchema())
        op, options, args = schemaconfigglue(parser,
                                             argv=['--foo', '{"bar": "baz"}'])

        self.assertEqual(options, {'foo': '{"bar": "baz"}'})
        self.assertEqual(parser.values(),
                         {'__main__': {
                             'foo': {
                                 'bar': 'baz'
                             }
                         }})
    def test_default_values(self):
        """Test parser reads default option values."""
        class MySchema(Schema):
            foo = BoolOption(default=True)

            class bar(Section):
                baz = IntOption()
                bla = StringOption(default='hello')

        schema = MySchema()
        config = StringIO("[bar]\nbaz=123")
        expected_values = {'__main__': {'foo': True},
                           'bar': {'baz': 123, 'bla': 'hello'}}
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertEquals(expected_values, parser.values())

        config = StringIO("[bar]\nbla=123")
        expected = {
            '__main__': {'foo': True},
            'bar': {'baz': 0, 'bla': '123'}}
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertEquals(expected, parser.values())
    def test_fatal_options(self):
        """Test parsing non-provided options marked as fatal."""
        class MySchema(Schema):
            foo = IntOption(fatal=True)
            bar = IntOption()
        schema = MySchema()
        config = StringIO("[__main__]\nfoo=123")
        expected = {'__main__': {'foo': 123, 'bar': 0}}
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertEquals(expected, parser.values())

        config = StringIO("[__main__]\nbar=123")
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertRaises(NoOptionError, parser.values)
示例#57
0
    def test_fatal_options(self):
        """Test parsing non-provided options marked as fatal."""
        class MySchema(Schema):
            foo = IntOption(fatal=True)
            bar = IntOption()
        schema = MySchema()
        config = StringIO("[__main__]\nfoo=123")
        expected = {'__main__': {'foo': 123, 'bar': 0}}
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertEquals(expected, parser.values())

        config = StringIO("[__main__]\nbar=123")
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        self.assertRaises(NoOptionError, parser.values)
示例#58
0
    def test_values_many_sections_different_options(self):
        """Test parser.values for many sections with different options."""
        class MySchema(Schema):
            class foo(Section):
                bar = IntOption()

            class bar(Section):
                baz = IntOption()

        config = StringIO("[foo]\nbar=3\n[bar]\nbaz=4")
        expected_values = {'foo': {'bar': 3}, 'bar': {'baz': 4}}

        schema = MySchema()
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        values = parser.values()
        self.assertEqual(values, expected_values)
示例#59
0
    def test_parse_no_strict_with_item(self):
        """Test DictOption parse in non-strict mode with an item spec."""
        class MySchema(Schema):
            foo = self.cls(item=self.cls(item=IntOption()))

        config = StringIO("""
[__main__]
foo = mydict
[mydict]
bar = baz
[baz]
wham=42
""")
        expected_values = {'__main__': {'foo': {'bar': {'wham': 42}}}}
        parser = SchemaConfigParser(MySchema())
        parser.readfp(config)
        self.assertEqual(parser.values(), expected_values)
示例#60
0
    def test_parse_json_raw_with_interpolation_marks(self):
        """Test DictOption parse json using raw=True when data has interpolation marks."""
        class MySchema(Schema):
            class logging(Section):
                formatters = self.cls(raw=True, item=self.cls())

        config = BytesIO(textwrap.dedent("""
            [logging]
            formatters = {"sample": {"format": "%(name)s"}}
            """).encode('utf-8'))
        expected = {'sample': {'format': '%(name)s'}}

        schema = MySchema()
        parser = SchemaConfigParser(schema)
        parser.readfp(config)
        parsed = parser.values('logging')['formatters']
        self.assertEqual(parsed, expected)