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