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_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_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_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_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_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_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_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_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_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_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)