Lib/test/test_cfgparser.py

   1 import ConfigParser
   2 import StringIO
   3
   4 from test_support import TestFailed, verify
   5
   6
   7 def basic(src):
   8     print "Testing basic accessors..."
   9     cf = ConfigParser.ConfigParser()
  10     sio = StringIO.StringIO(src)
  11     cf.readfp(sio)
  12     L = cf.sections()
  13     L.sort()
  14     verify(L == [r'Commented Bar',
  15                  r'Foo Bar',
  16                  r'Internationalized Stuff',
  17                  r'Section\with$weird%characters[' '\t',
  18                  r'Spacey Bar',
  19                  ],
  20            "unexpected list of section names")
  21
  22     # The use of spaces in the section names serves as a regression test for
  23     # SourceForge bug #115357.
  24     # http://sourceforge.net/bugs/?func=detailbug&group_id=5470&bug_id=115357
  25     verify(cf.get('Foo Bar', 'foo', raw=1) == 'bar')
  26     verify(cf.get('Spacey Bar', 'foo', raw=1) == 'bar')
  27     verify(cf.get('Commented Bar', 'foo', raw=1) == 'bar')
  28
  29     verify('__name__' not in cf.options("Foo Bar"),
  30            '__name__ "option" should not be exposed by the API!')
  31
  32     # Make sure the right things happen for remove_option();
  33     # added to include check for SourceForge bug #123324:
  34     verify(cf.remove_option('Foo Bar', 'foo'),
  35            "remove_option() failed to report existance of option")
  36     verify(not cf.has_option('Foo Bar', 'foo'),
  37            "remove_option() failed to remove option")
  38     verify(not cf.remove_option('Foo Bar', 'foo'),
  39            "remove_option() failed to report non-existance of option"
  40            " that was removed")
  41     try:
  42         cf.remove_option('No Such Section', 'foo')
  43     except ConfigParser.NoSectionError:
  44         pass
  45     else:
  46         raise TestFailed(
  47             "remove_option() failed to report non-existance of option"
  48             " that never existed")
  49
  50
  51 def case_sensitivity():
  52     print "Testing case sensitivity..."
  53     cf = ConfigParser.ConfigParser()
  54     cf.add_section("A")
  55     cf.add_section("a")
  56     L = cf.sections()
  57     L.sort()
  58     verify(L == ["A", "a"])
  59     cf.set("a", "B", "value")
  60     verify(cf.options("a") == ["b"])
  61     verify(cf.get("a", "b", raw=1) == "value",
  62            "could not locate option, expecting case-insensitive option names")
  63     verify(cf.has_option("a", "b"))
  64     cf.set("A", "A-B", "A-B value")
  65     for opt in ("a-b", "A-b", "a-B", "A-B"):
  66         verify(cf.has_option("A", opt),
  67                "has_option() returned false for option which should exist")
  68     verify(cf.options("A") == ["a-b"])
  69     verify(cf.options("a") == ["b"])
  70     cf.remove_option("a", "B")
  71     verify(cf.options("a") == [])
  72
  73     # SF bug #432369:
  74     cf = ConfigParser.ConfigParser()
  75     sio = StringIO.StringIO("[MySection]\nOption: first line\n\tsecond line\n")
  76     cf.readfp(sio)
  77     verify(cf.options("MySection") == ["option"])
  78     verify(cf.get("MySection", "Option") == "first line\nsecond line")
  79
  80
  81 def interpolation(src):
  82     print "Testing value interpolation..."
  83     cf = ConfigParser.ConfigParser({"getname": "%(__name__)s"})
  84     sio = StringIO.StringIO(src)
  85     cf.readfp(sio)
  86     verify(cf.get("Foo", "getname") == "Foo")
  87     verify(cf.get("Foo", "bar") == "something with interpolation (1 step)")
  88     verify(cf.get("Foo", "bar9")
  89            == "something with lots of interpolation (9 steps)")
  90     verify(cf.get("Foo", "bar10")
  91            == "something with lots of interpolation (10 steps)")
  92     expect_get_error(cf, ConfigParser.InterpolationDepthError, "Foo", "bar11")
  93
  94
  95 def parse_errors():
  96     print "Testing parse errors..."
  97     expect_parse_error(ConfigParser.ParsingError,
  98                        """[Foo]\n  extra-spaces: splat\n""")
  99     expect_parse_error(ConfigParser.ParsingError,
 100                        """[Foo]\n  extra-spaces= splat\n""")
 101     expect_parse_error(ConfigParser.ParsingError,
 102                        """[Foo]\noption-without-value\n""")
 103     expect_parse_error(ConfigParser.ParsingError,
 104                        """[Foo]\n:value-without-option-name\n""")
 105     expect_parse_error(ConfigParser.ParsingError,
 106                        """[Foo]\n=value-without-option-name\n""")
 107     expect_parse_error(ConfigParser.MissingSectionHeaderError,
 108                        """No Section!\n""")
 109
 110
 111 def query_errors():
 112     print "Testing query interface..."
 113     cf = ConfigParser.ConfigParser()
 114     verify(cf.sections() == [],
 115            "new ConfigParser should have no defined sections")
 116     verify(not cf.has_section("Foo"),
 117            "new ConfigParser should have no acknowledged sections")
 118     try:
 119         cf.options("Foo")
 120     except ConfigParser.NoSectionError, e:
 121         pass
 122     else:
 123         raise TestFailed(
 124             "Failed to catch expected NoSectionError from options()")
 125     try:
 126         cf.set("foo", "bar", "value")
 127     except ConfigParser.NoSectionError, e:
 128         pass
 129     else:
 130         raise TestFailed("Failed to catch expected NoSectionError from set()")
 131     expect_get_error(cf, ConfigParser.NoSectionError, "foo", "bar")
 132     cf.add_section("foo")
 133     expect_get_error(cf, ConfigParser.NoOptionError, "foo", "bar")
 134
 135
 136 def weird_errors():
 137     print "Testing miscellaneous error conditions..."
 138     cf = ConfigParser.ConfigParser()
 139     cf.add_section("Foo")
 140     try:
 141         cf.add_section("Foo")
 142     except ConfigParser.DuplicateSectionError, e:
 143         pass
 144     else:
 145         raise TestFailed("Failed to catch expected DuplicateSectionError")
 146
 147
 148 def expect_get_error(cf, exctype, section, option, raw=0):
 149     try:
 150         cf.get(section, option, raw=raw)
 151     except exctype, e:
 152         pass
 153     else:
 154         raise TestFailed("Failed to catch expected " + exctype.__name__)
 155
 156
 157 def expect_parse_error(exctype, src):
 158     cf = ConfigParser.ConfigParser()
 159     sio = StringIO.StringIO(src)
 160     try:
 161         cf.readfp(sio)
 162     except exctype, e:
 163         pass
 164     else:
 165         raise TestFailed("Failed to catch expected " + exctype.__name__)
 166
 167
 168 basic(r"""
 169 [Foo Bar]
 170 foo=bar
 171 [Spacey Bar]
 172 foo = bar
 173 [Commented Bar]
 174 foo: bar ; comment
 175 [Section\with$weird%characters[""" '\t' r"""]
 176 [Internationalized Stuff]
 177 foo[bg]: Bulgarian
 178 foo=Default
 179 foo[en]=English
 180 foo[de]=Deutsch
 181 """)
 182 case_sensitivity()
 183 interpolation(r"""
 184 [Foo]
 185 bar=something %(with1)s interpolation (1 step)
 186 bar9=something %(with9)s lots of interpolation (9 steps)
 187 bar10=something %(with10)s lots of interpolation (10 steps)
 188 bar11=something %(with11)s lots of interpolation (11 steps)
 189 with11=%(with10)s
 190 with10=%(with9)s
 191 with9=%(with8)s
 192 with8=%(with7)s
 193 with7=%(with6)s
 194 with6=%(with5)s
 195 with5=%(with4)s
 196 with4=%(with3)s
 197 with3=%(with2)s
 198 with2=%(with1)s
 199 with1=with
 200
 201 [Mutual Recursion]
 202 foo=%(bar)s
 203 bar=%(foo)s
 204 """)
 205 parse_errors()
 206 query_errors()
 207 weird_errors()