Using appropriate checks in tests

Lib/test/test_configparser.py

 import collections
 import configparser
 import io
 import os
 import sys
 import textwrap
 import unittest
 import warnings
 
 from test import support
@@ skipping 14 matching lines @@
 
     def iterkeys(self):
         return iter(self.keys())
 
     def itervalues(self):
         return iter(self.values())
 
     __iter__ = iterkeys
 
 
-class CfgParserTestCaseClass(unittest.TestCase):
+class CfgParserTestCaseClass:
     allow_no_value = False
     delimiters = ('=', ':')
     comment_prefixes = (';', '#')
     inline_comment_prefixes = (';', '#')
     empty_lines_in_values = True
     dict_type = configparser._default_dict
     strict = False
     default_section = configparser.DEFAULTSECT
     interpolation = configparser._UNSET
 
@@ skipping 573 matching lines @@
             with self.assertRaises(configparser.DuplicateSectionError) as cm:
                 cf.read_string(textwrap.dedent("""\
                     [Foo]
                     will this be added{equals}True
                     [Bar]
                     what about this{equals}True
                     [Foo]
                     oops{equals}this won't
                 """.format(equals=self.delimiters[0])), source='<foo-bar>')
             e = cm.exception
-            self.assertEqual(str(e), "While reading from <foo-bar> [line  5]: "
-                                     "section 'Foo' already exists")
+            self.assertEqual(str(e), "While reading from '<foo-bar>' "
+                                     "[line  5]: section 'Foo' already exists")
             self.assertEqual(e.args, ("Foo", '<foo-bar>', 5))
 
             with self.assertRaises(configparser.DuplicateOptionError) as cm:
                 cf.read_dict({'Bar': {'opt': 'val', 'OPT': 'is really `opt`'}})
             e = cm.exception
-            self.assertEqual(str(e), "While reading from <dict>: option 'opt' "
-                                     "in section 'Bar' already exists")
+            self.assertEqual(str(e), "While reading from '<dict>': option "
+                                     "'opt' in section 'Bar' already exists")
             self.assertEqual(e.args, ("Bar", "opt", "<dict>", None))
 
     def test_write(self):
         config_string = (
             "[Long Line]\n"
             "foo{0[0]} this line is much, much longer than my editor\n"
             "   likes it.\n"
             "[{default_section}]\n"
             "foo{0[1]} another very\n"
             " long line\n"
@@ skipping 52 matching lines @@
             pass
         cf.set("sect", "option1", "splat")
         cf.set("sect", "option1", mystr("splat"))
         cf.set("sect", "option2", "splat")
         cf.set("sect", "option2", mystr("splat"))
         cf.set("sect", "option1", "splat")
         cf.set("sect", "option2", "splat")
 
     def test_read_returns_file_list(self):
         if self.delimiters[0] != '=':
-            # skip reading the file if we're using an incompatible format
-            return
+            self.skipTest('incompatible format')
         file1 = support.findfile("cfgparser.1")
         # check when we pass a mix of readable and non-readable files:
         cf = self.newconfig()
         parsed_files = cf.read([file1, "nonexistent-file"])
         self.assertEqual(parsed_files, [file1])
         self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
         # check when we pass only a filename:
         cf = self.newconfig()
         parsed_files = cf.read(file1)
         self.assertEqual(parsed_files, [file1])
@@ skipping 41 matching lines @@
             name {0[0]} %(value)s
             key{0[1]} |%(name)s|
             getdefault{0[1]} |%(default)s|
         """.format(self.delimiters), defaults={"default": "<default>"})
         L = list(cf.items("section", vars={'value': 'value'}))
         L.sort()
         self.assertEqual(L, expected)
         with self.assertRaises(configparser.NoSectionError):
             cf.items("no such section")
 
-
-class StrictTestCase(BasicTestCase):
+    def test_popitem(self):
+        cf = self.fromstring("""
+            [section1]
+            name1 {0[0]} value1
+            [section2]
+            name2 {0[0]} value2
+            [section3]
+            name3 {0[0]} value3
+        """.format(self.delimiters), defaults={"default": "<default>"})
+        self.assertEqual(cf.popitem()[0], 'section1')
+        self.assertEqual(cf.popitem()[0], 'section2')
+        self.assertEqual(cf.popitem()[0], 'section3')
+        with self.assertRaises(KeyError):
+            cf.popitem()
+
+    def test_clear(self):
+        cf = self.newconfig({"foo": "Bar"})
+        self.assertEqual(
+            cf.get(self.default_section, "Foo"), "Bar",
+            "could not locate option, expecting case-insensitive option names")
+        cf['zing'] = {'option1': 'value1', 'option2': 'value2'}
+        self.assertEqual(cf.sections(), ['zing'])
+        self.assertEqual(set(cf['zing'].keys()), {'option1', 'option2', 'foo'})
+        cf.clear()
+        self.assertEqual(set(cf.sections()), set())
+        self.assertEqual(set(cf[self.default_section].keys()), {'foo'})
+
+    def test_setitem(self):
+        cf = self.fromstring("""
+            [section1]
+            name1 {0[0]} value1
+            [section2]
+            name2 {0[0]} value2
+            [section3]
+            name3 {0[0]} value3
+        """.format(self.delimiters), defaults={"nameD": "valueD"})
+        self.assertEqual(set(cf['section1'].keys()), {'name1', 'named'})
+        self.assertEqual(set(cf['section2'].keys()), {'name2', 'named'})
+        self.assertEqual(set(cf['section3'].keys()), {'name3', 'named'})
+        self.assertEqual(cf['section1']['name1'], 'value1')
+        self.assertEqual(cf['section2']['name2'], 'value2')
+        self.assertEqual(cf['section3']['name3'], 'value3')
+        self.assertEqual(cf.sections(), ['section1', 'section2', 'section3'])
+        cf['section2'] = {'name22': 'value22'}
+        self.assertEqual(set(cf['section2'].keys()), {'name22', 'named'})
+        self.assertEqual(cf['section2']['name22'], 'value22')
+        self.assertNotIn('name2', cf['section2'])
+        self.assertEqual(cf.sections(), ['section1', 'section2', 'section3'])
+        cf['section3'] = {}
+        self.assertEqual(set(cf['section3'].keys()), {'named'})
+        self.assertNotIn('name3', cf['section3'])
+        self.assertEqual(cf.sections(), ['section1', 'section2', 'section3'])
+        cf[self.default_section] = {}
+        self.assertEqual(set(cf[self.default_section].keys()), set())
+        self.assertEqual(set(cf['section1'].keys()), {'name1'})
+        self.assertEqual(set(cf['section2'].keys()), {'name22'})
+        self.assertEqual(set(cf['section3'].keys()), set())
+        self.assertEqual(cf.sections(), ['section1', 'section2', 'section3'])
+
+
+class StrictTestCase(BasicTestCase, unittest.TestCase):
     config_class = configparser.RawConfigParser
     strict = True
 
 
-class ConfigParserTestCase(BasicTestCase):
+class ConfigParserTestCase(BasicTestCase, unittest.TestCase):
     config_class = configparser.ConfigParser
 
     def test_interpolation(self):
         cf = self.get_interpolation_config()
         eq = self.assertEqual
         eq(cf.get("Foo", "bar"), "something with interpolation (1 step)")
         eq(cf.get("Foo", "bar9"),
            "something with lots of interpolation (9 steps)")
         eq(cf.get("Foo", "bar10"),
            "something with lots of interpolation (10 steps)")
@@ skipping 68 matching lines @@
         self.assertRaises(TypeError, cf.set, "sect", "option2", 1.0)
         self.assertRaises(TypeError, cf.set, "sect", "option2", object())
         self.assertRaises(TypeError, cf.set, "sect", 123, "invalid opt name!")
         self.assertRaises(TypeError, cf.add_section, 123)
 
     def test_add_section_default(self):
         cf = self.newconfig()
         self.assertRaises(ValueError, cf.add_section, self.default_section)
 
 
-class ConfigParserTestCaseNoInterpolation(BasicTestCase):
+class ConfigParserTestCaseNoInterpolation(BasicTestCase, unittest.TestCase):
     config_class = configparser.ConfigParser
     interpolation = None
     ini = textwrap.dedent("""
         [numbers]
         one = 1
         two = %(one)s * 2
         three = ${common:one} * 3
 
         [hexen]
         sixteen = ${numbers:two} * 8
@@ skipping 44 matching lines @@
         self.assertEqual(cf.get("sect", "option2"), "foo%%bar")
 
 class ConfigParserTestCaseNonStandardDelimiters(ConfigParserTestCase):
     delimiters = (':=', '$')
     comment_prefixes = ('//', '"')
     inline_comment_prefixes = ('//', '"')
 
 class ConfigParserTestCaseNonStandardDefaultSection(ConfigParserTestCase):
     default_section = 'general'
 
-class MultilineValuesTestCase(BasicTestCase):
+class MultilineValuesTestCase(BasicTestCase, unittest.TestCase):
     config_class = configparser.ConfigParser
     wonderful_spam = ("I'm having spam spam spam spam "
                       "spam spam spam beaked beans spam "
                       "spam spam and spam!").replace(' ', '\t\n')
 
     def setUp(self):
         cf = self.newconfig()
         for i in range(100):
             s = 'section{}'.format(i)
             cf.add_section(s)
             for j in range(10):
                 cf.set(s, 'lovely_spam{}'.format(j), self.wonderful_spam)
         with open(support.TESTFN, 'w') as f:
             cf.write(f)
 
     def tearDown(self):
         os.unlink(support.TESTFN)
 
     def test_dominating_multiline_values(self):
         # We're reading from file because this is where the code changed
         # during performance updates in Python 3.2
         cf_from_file = self.newconfig()
         with open(support.TESTFN) as f:
             cf_from_file.read_file(f)
         self.assertEqual(cf_from_file.get('section8', 'lovely_spam4'),
                          self.wonderful_spam.replace('\t\n', '\n'))
 
-class RawConfigParserTestCase(BasicTestCase):
+class RawConfigParserTestCase(BasicTestCase, unittest.TestCase):
     config_class = configparser.RawConfigParser
 
     def test_interpolation(self):
         cf = self.get_interpolation_config()
         eq = self.assertEqual
         eq(cf.get("Foo", "bar"),
            "something %(with1)s interpolation (1 step)")
         eq(cf.get("Foo", "bar9"),
            "something %(with9)s lots of interpolation (9 steps)")
         eq(cf.get("Foo", "bar10"),
@@ skipping 26 matching lines @@
             # default dictionary (OrderedDict)
             cf.optionxform = lambda x: x
             cf.set('non-string', 1, 1)
             self.assertEqual(cf.get('non-string', 1), 1)
 
 class RawConfigParserTestCaseNonStandardDelimiters(RawConfigParserTestCase):
     delimiters = (':=', '$')
     comment_prefixes = ('//', '"')
     inline_comment_prefixes = ('//', '"')
 
-class RawConfigParserTestSambaConf(CfgParserTestCaseClass):
+class RawConfigParserTestSambaConf(CfgParserTestCaseClass, unittest.TestCase):
     config_class = configparser.RawConfigParser
     comment_prefixes = ('#', ';', '----')
     inline_comment_prefixes = ('//',)
     empty_lines_in_values = False
 
     def test_reading(self):
         smbconf = support.findfile("cfgparser.2")
         # check when we pass a mix of readable and non-readable files:
         cf = self.newconfig()
         parsed_files = cf.read([smbconf, "nonexistent-file"], encoding='utf-8')
         self.assertEqual(parsed_files, [smbconf])
         sections = ['global', 'homes', 'printers',
                     'print$', 'pdf-generator', 'tmp', 'Agustin']
         self.assertEqual(cf.sections(), sections)
         self.assertEqual(cf.get("global", "workgroup"), "MDKGROUP")
         self.assertEqual(cf.getint("global", "max log size"), 50)
         self.assertEqual(cf.get("global", "hosts allow"), "127.")
         self.assertEqual(cf.get("tmp", "echo command"), "cat %s; rm %s")
 
-class ConfigParserTestCaseExtendedInterpolation(BasicTestCase):
+class ConfigParserTestCaseExtendedInterpolation(BasicTestCase, unittest.TestCase):
     config_class = configparser.ConfigParser
     interpolation = configparser.ExtendedInterpolation()
     default_section = 'common'
     strict = True
 
     def fromstring(self, string, defaults=None, optionxform=None):
         cf = self.newconfig(defaults)
         if optionxform:
             cf.optionxform = optionxform
         cf.read_string(string)
@@ skipping 153 matching lines @@
             cf['interpolation fail']['case4']
         with self.assertRaises(configparser.InterpolationSyntaxError):
             cf['interpolation fail']['case5']
         with self.assertRaises(ValueError):
             cf['interpolation fail']['case6'] = "BLACK $ABBATH"
 
 
 class ConfigParserTestCaseNoValue(ConfigParserTestCase):
     allow_no_value = True
 
-class ConfigParserTestCaseTrickyFile(CfgParserTestCaseClass):
+class ConfigParserTestCaseTrickyFile(CfgParserTestCaseClass, unittest.TestCase):
     config_class = configparser.ConfigParser
     delimiters = {'='}
     comment_prefixes = {'#'}
     allow_no_value = True
 
     def test_cfgparser_dot_3(self):
         tricky = support.findfile("cfgparser.3")
         cf = self.newconfig()
         self.assertEqual(len(cf.read(tricky, encoding='utf-8')), 1)
         self.assertEqual(cf.sections(), ['strange',
@@ skipping 76 matching lines @@
         self.assertEqual(output.getvalue(),
                          "[a]\n"
                          "k = v\n\n"
                          "[b]\n"
                          "o1 = 4\n"
                          "o2 = 3\n"
                          "o3 = 2\n"
                          "o4 = 1\n\n")
 
 
-class CompatibleTestCase(CfgParserTestCaseClass):
+class CompatibleTestCase(CfgParserTestCaseClass, unittest.TestCase):
     config_class = configparser.RawConfigParser
     comment_prefixes = '#;'
     inline_comment_prefixes = ';'
 
     def test_comment_handling(self):
         config_string = textwrap.dedent("""\
         [Commented Bar]
         baz=qwe ; a comment
         foo: bar # not a comment!
         # but this is a comment
         ; another comment
         quirk: this;is not a comment
         ; a space must precede an inline comment
         """)
         cf = self.fromstring(config_string)
         self.assertEqual(cf.get('Commented Bar', 'foo'),
                          'bar # not a comment!')
         self.assertEqual(cf.get('Commented Bar', 'baz'), 'qwe')
         self.assertEqual(cf.get('Commented Bar', 'quirk'),
                          'this;is not a comment')
 
-class CopyTestCase(BasicTestCase):
+class CopyTestCase(BasicTestCase, unittest.TestCase):
     config_class = configparser.ConfigParser
 
     def fromstring(self, string, defaults=None):
         cf = self.newconfig(defaults)
         cf.read_string(string)
         cf_copy = self.newconfig()
         cf_copy.read_dict(cf)
         # we have to clean up option duplicates that appeared because of
         # the magic DEFAULTSECT behaviour.
         for section in cf_copy.values():
@@ skipping 21 matching lines @@
 def readline_generator(f):
     """As advised in Doc/library/configparser.rst."""
     line = f.readline()
     while line:
         yield line
         line = f.readline()
 
 
 class ReadFileTestCase(unittest.TestCase):
     def test_file(self):
-        file_path = support.findfile("cfgparser.1")
-        parser = configparser.ConfigParser()
-        with open(file_path) as f:
-            parser.read_file(f)
-        self.assertIn("Foo Bar", parser)
-        self.assertIn("foo", parser["Foo Bar"])
-        self.assertEqual(parser["Foo Bar"]["foo"], "newbar")
+        file_paths = [support.findfile("cfgparser.1")]
+        try:
+            file_paths.append(file_paths[0].encode('utf8'))
+        except UnicodeEncodeError:
+            pass   # unfortunately we can't test bytes on this path
+        for file_path in file_paths:
+            parser = configparser.ConfigParser()
+            with open(file_path) as f:
+                parser.read_file(f)
+            self.assertIn("Foo Bar", parser)
+            self.assertIn("foo", parser["Foo Bar"])
+            self.assertEqual(parser["Foo Bar"]["foo"], "newbar")
 
     def test_iterable(self):
         lines = textwrap.dedent("""
         [Foo Bar]
         foo=newbar""").strip().split('\n')
         parser = configparser.ConfigParser()
         parser.read_file(lines)
         self.assertIn("Foo Bar", parser)
         self.assertIn("foo", parser["Foo Bar"])
         self.assertEqual(parser["Foo Bar"]["foo"], "newbar")
 
     def test_readline_generator(self):
         """Issue #11670."""
         parser = configparser.ConfigParser()
         with self.assertRaises(TypeError):
             parser.read_file(FakeFile())
         parser.read_file(readline_generator(FakeFile()))
         self.assertIn("Foo Bar", parser)
         self.assertIn("foo", parser["Foo Bar"])
         self.assertEqual(parser["Foo Bar"]["foo"], "newbar")
+
+    def test_source_as_bytes(self):
+        """Issue #18260."""
+        lines = textwrap.dedent("""
+        [badbad]
+        [badbad]""").strip().split('\n')
+        parser = configparser.ConfigParser()
+        with self.assertRaises(configparser.DuplicateSectionError) as dse:
+            parser.read_file(lines, source=b"badbad")
+        self.assertEqual(
+            str(dse.exception),
+            "While reading from b'badbad' [line  2]: section 'badbad' "
+            "already exists"
+        )
+        lines = textwrap.dedent("""
+        [badbad]
+        bad = bad
+        bad = bad""").strip().split('\n')
+        parser = configparser.ConfigParser()
+        with self.assertRaises(configparser.DuplicateOptionError) as dse:
+            parser.read_file(lines, source=b"badbad")
+        self.assertEqual(
+            str(dse.exception),
+            "While reading from b'badbad' [line  3]: option 'bad' in section "
+            "'badbad' already exists"
+        )
+        lines = textwrap.dedent("""
+        [badbad]
+        = bad""").strip().split('\n')
+        parser = configparser.ConfigParser()
+        with self.assertRaises(configparser.ParsingError) as dse:
+            parser.read_file(lines, source=b"badbad")
+        self.assertEqual(
+            str(dse.exception),
+            "Source contains parsing errors: b'badbad'\n\t[line  2]: '= bad'"
+        )
+        lines = textwrap.dedent("""
+        [badbad
+        bad = bad""").strip().split('\n')
+        parser = configparser.ConfigParser()
+        with self.assertRaises(configparser.MissingSectionHeaderError) as dse:
+            parser.read_file(lines, source=b"badbad")
+        self.assertEqual(
+            str(dse.exception),
+            "File contains no section headers.\nfile: b'badbad', line: 1\n"
+            "'[badbad'"
+        )
 
 
 class CoverageOneHundredTestCase(unittest.TestCase):
     """Covers edge cases in the codebase."""
 
     def test_duplicate_option_error(self):
         error = configparser.DuplicateOptionError('section', 'option')
         self.assertEqual(error.section, 'section')
         self.assertEqual(error.option, 'option')
         self.assertEqual(error.source, None)
@@ skipping 247 matching lines @@
         self.assertEqual(s['k4'], 'v4;still v4')
         self.assertEqual(s['k5'], 'v5;still v5')
         self.assertEqual(s['k6'], 'v6;still v6; and still v6')
         self.assertEqual(s['k7'], 'v7;still v7; and still v7')
         s = cfg['multiprefix']
         self.assertEqual(s['k1'], 'v1;still v1')
         self.assertEqual(s['k2'], 'v2')
         self.assertEqual(s['k3'], 'v3;#//still v3# and still v3')
 
 
-def test_main():
-    support.run_unittest(
-        ConfigParserTestCase,
-        ConfigParserTestCaseNonStandardDelimiters,
-        ConfigParserTestCaseNoValue,
-        ConfigParserTestCaseExtendedInterpolation,
-        ConfigParserTestCaseLegacyInterpolation,
-        ConfigParserTestCaseNoInterpolation,
-        ConfigParserTestCaseTrickyFile,
-        MultilineValuesTestCase,
-        RawConfigParserTestCase,
-        RawConfigParserTestCaseNonStandardDelimiters,
-        RawConfigParserTestSambaConf,
-        SortedTestCase,
-        Issue7005TestCase,
-        StrictTestCase,
-        CompatibleTestCase,
-        CopyTestCase,
-        ConfigParserTestCaseNonStandardDefaultSection,
-        ReadFileTestCase,
-        CoverageOneHundredTestCase,
-        ExceptionPicklingTestCase,
-        InlineCommentStrippingTestCase,
-        )
+if __name__ == '__main__':
+    unittest.main()