import ConfigParser

import StringIO

import unittest

import UserDict

from test import test_support

class SortedDict(UserDict.UserDict):

    def items(self):

        result = self.data.items()

        result.sort()

        return result

    def keys(self):

        result = self.data.keys()

        result.sort()

        return result

    def values(self):

        result = self.items()

        return [i[1] for i in values]

    def iteritems(self): return iter(self.items())

    def iterkeys(self): return iter(self.keys())

    __iter__ = iterkeys

    def itervalues(self): return iter(self.values())

class TestCaseBase(unittest.TestCase):

    def newconfig(self, defaults=None):

        if defaults is None:

            self.cf = self.config_class()

        else:

            self.cf = self.config_class(defaults)

        return self.cf

    def fromstring(self, string, defaults=None):

        cf = self.newconfig(defaults)

        sio = StringIO.StringIO(string)

        cf.readfp(sio)

        return cf

    def test_basic(self):

        cf = self.fromstring(

            "[Foo Bar]\n"

            "foo=bar\n"

            "[Spacey Bar]\n"

            "foo = bar\n"

            "[Commented Bar]\n"

            "foo: bar ; comment\n"

            "[Long Line]\n"

            "foo: this line is much, much longer than my editor\n"

            "   likes it.\n"

            "[Section\\with$weird%characters[\t]\n"

            "[Internationalized Stuff]\n"

            "foo[bg]: Bulgarian\n"

            "foo=Default\n"

            "foo[en]=English\n"

            "foo[de]=Deutsch\n"

            "[Spaces]\n"

            "key with spaces : value\n"

            "another with spaces = splat!\n"

            )

        L = cf.sections()

        L.sort()

        eq = self.assertEqual

        eq(L, [r'Commented Bar',

               r'Foo Bar',

               r'Internationalized Stuff',

               r'Long Line',

               r'Section\with$weird%characters[' '\t',

               r'Spaces',

               r'Spacey Bar',

               ])

        # The use of spaces in the section names serves as a

        # regression test for SourceForge bug #583248:

        # http://www.python.org/sf/583248

        eq(cf.get('Foo Bar', 'foo'), 'bar')

        eq(cf.get('Spacey Bar', 'foo'), 'bar')

        eq(cf.get('Commented Bar', 'foo'), 'bar')

        eq(cf.get('Spaces', 'key with spaces'), 'value')

        eq(cf.get('Spaces', 'another with spaces'), 'splat!')

        self.failIf('__name__' in cf.options("Foo Bar"),

                    '__name__ "option" should not be exposed by the API!')

        # Make sure the right things happen for remove_option();

        # added to include check for SourceForge bug #123324:

        self.failUnless(cf.remove_option('Foo Bar', 'foo'),

                        "remove_option() failed to report existance of option")

        self.failIf(cf.has_option('Foo Bar', 'foo'),

                    "remove_option() failed to remove option")

        self.failIf(cf.remove_option('Foo Bar', 'foo'),

                    "remove_option() failed to report non-existance of option"

                    " that was removed")

        self.assertRaises(ConfigParser.NoSectionError,

                          cf.remove_option, 'No Such Section', 'foo')

        eq(cf.get('Long Line', 'foo'),

           'this line is much, much longer than my editor\nlikes it.')

    def test_case_sensitivity(self):

        cf = self.newconfig()

        cf.add_section("A")

        cf.add_section("a")

        L = cf.sections()

        L.sort()

        eq = self.assertEqual

        eq(L, ["A", "a"])

        cf.set("a", "B", "value")

        eq(cf.options("a"), ["b"])

        eq(cf.get("a", "b"), "value",

           "could not locate option, expecting case-insensitive option names")

        self.failUnless(cf.has_option("a", "b"))

        cf.set("A", "A-B", "A-B value")

        for opt in ("a-b", "A-b", "a-B", "A-B"):

            self.failUnless(

                cf.has_option("A", opt),

                "has_option() returned false for option which should exist")

        eq(cf.options("A"), ["a-b"])

        eq(cf.options("a"), ["b"])

        cf.remove_option("a", "B")

        eq(cf.options("a"), [])

        # SF bug #432369:

        cf = self.fromstring(

            "[MySection]\nOption: first line\n\tsecond line\n")

        eq(cf.options("MySection"), ["option"])

        eq(cf.get("MySection", "Option"), "first line\nsecond line")

        # SF bug #561822:

        cf = self.fromstring("[section]\nnekey=nevalue\n",

                             defaults={"key":"value"})

        self.failUnless(cf.has_option("section", "Key"))

    def test_default_case_sensitivity(self):

        cf = self.newconfig({"foo": "Bar"})

        self.assertEqual(

            cf.get("DEFAULT", "Foo"), "Bar",

            "could not locate option, expecting case-insensitive option names")

        cf = self.newconfig({"Foo": "Bar"})

        self.assertEqual(

            cf.get("DEFAULT", "Foo"), "Bar",

            "could not locate option, expecting case-insensitive defaults")

    def test_parse_errors(self):

        self.newconfig()

        self.parse_error(ConfigParser.ParsingError,

                         "[Foo]\n  extra-spaces: splat\n")

        self.parse_error(ConfigParser.ParsingError,

                         "[Foo]\n  extra-spaces= splat\n")

        self.parse_error(ConfigParser.ParsingError,

                         "[Foo]\noption-without-value\n")

        self.parse_error(ConfigParser.ParsingError,

                         "[Foo]\n:value-without-option-name\n")

        self.parse_error(ConfigParser.ParsingError,

                         "[Foo]\n=value-without-option-name\n")

        self.parse_error(ConfigParser.MissingSectionHeaderError,

                         "No Section!\n")

    def parse_error(self, exc, src):

        sio = StringIO.StringIO(src)

        self.assertRaises(exc, self.cf.readfp, sio)

    def test_query_errors(self):

        cf = self.newconfig()

        self.assertEqual(cf.sections(), [],

                         "new ConfigParser should have no defined sections")

        self.failIf(cf.has_section("Foo"),

                    "new ConfigParser should have no acknowledged sections")

        self.assertRaises(ConfigParser.NoSectionError,

                          cf.options, "Foo")

        self.assertRaises(ConfigParser.NoSectionError,

                          cf.set, "foo", "bar", "value")

        self.get_error(ConfigParser.NoSectionError, "foo", "bar")

        cf.add_section("foo")

        self.get_error(ConfigParser.NoOptionError, "foo", "bar")

    def get_error(self, exc, section, option):

        try:

            self.cf.get(section, option)

        except exc, e:

            return e

        else:

            self.fail("expected exception type %s.%s"

                      % (exc.__module__, exc.__name__))

    def test_boolean(self):

        cf = self.fromstring(

            "[BOOLTEST]\n"

            "T1=1\n"

            "T2=TRUE\n"

            "T3=True\n"

            "T4=oN\n"

            "T5=yes\n"

            "F1=0\n"

            "F2=FALSE\n"

            "F3=False\n"

            "F4=oFF\n"

            "F5=nO\n"

            "E1=2\n"

            "E2=foo\n"

            "E3=-1\n"

            "E4=0.1\n"

            "E5=FALSE AND MORE"

            )

        for x in range(1, 5):

            self.failUnless(cf.getboolean('BOOLTEST', 't%d' % x))

            self.failIf(cf.getboolean('BOOLTEST', 'f%d' % x))

            self.assertRaises(ValueError,

                              cf.getboolean, 'BOOLTEST', 'e%d' % x)

    def test_weird_errors(self):

        cf = self.newconfig()

        cf.add_section("Foo")

        self.assertRaises(ConfigParser.DuplicateSectionError,

                          cf.add_section, "Foo")

    def test_write(self):

        cf = self.fromstring(

            "[Long Line]\n"

            "foo: this line is much, much longer than my editor\n"

            "   likes it.\n"

            "[DEFAULT]\n"

            "foo: another very\n"

            " long line"

            )

        output = StringIO.StringIO()

        cf.write(output)

        self.assertEqual(

            output.getvalue(),

            "[DEFAULT]\n"

            "foo = another very\n"

            "\tlong line\n"

            "\n"

            "[Long Line]\n"

            "foo = this line is much, much longer than my editor\n"

            "\tlikes it.\n"

            "\n"

            )

    def test_set_string_types(self):

        cf = self.fromstring("[sect]\n"

                             "option1=foo\n")

        # Check that we don't get an exception when setting values in

        # an existing section using strings:

        class mystr(str):

            pass

        cf.set("sect", "option1", "splat")

        cf.set("sect", "option1", mystr("splat"))

        cf.set("sect", "option2", "splat")

        cf.set("sect", "option2", mystr("splat"))

        try:

            unicode

        except NameError:

            pass

        else:

            cf.set("sect", "option1", unicode("splat"))

            cf.set("sect", "option2", unicode("splat"))

    def test_read_returns_file_list(self):

        file1 = test_support.findfile("cfgparser.1")

        # check when we pass a mix of readable and non-readable files:

        cf = self.newconfig()

        parsed_files = cf.read([file1, "nonexistant-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])

        self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")

        # check when we pass only missing files:

        cf = self.newconfig()

        parsed_files = cf.read(["nonexistant-file"])

        self.assertEqual(parsed_files, [])

        # check when we pass no files:

        cf = self.newconfig()

        parsed_files = cf.read([])

        self.assertEqual(parsed_files, [])

    # shared by subclasses

    def get_interpolation_config(self):

        return self.fromstring(

            "[Foo]\n"

            "bar=something %(with1)s interpolation (1 step)\n"

            "bar9=something %(with9)s lots of interpolation (9 steps)\n"

            "bar10=something %(with10)s lots of interpolation (10 steps)\n"

            "bar11=something %(with11)s lots of interpolation (11 steps)\n"

            "with11=%(with10)s\n"

            "with10=%(with9)s\n"

            "with9=%(with8)s\n"

            "with8=%(With7)s\n"

            "with7=%(WITH6)s\n"

            "with6=%(with5)s\n"

            "With5=%(with4)s\n"

            "WITH4=%(with3)s\n"

            "with3=%(with2)s\n"

            "with2=%(with1)s\n"

            "with1=with\n"

            "\n"

            "[Mutual Recursion]\n"

            "foo=%(bar)s\n"

            "bar=%(foo)s\n"

            "\n"

            "[Interpolation Error]\n"

            "name=%(reference)s\n",

            # no definition for 'reference'

            defaults={"getname": "%(__name__)s"})

    def check_items_config(self, expected):

        cf = self.fromstring(

            "[section]\n"

            "name = value\n"

            "key: |%(name)s| \n"

            "getdefault: |%(default)s|\n"

            "getname: |%(__name__)s|",

            defaults={"default": "<default>"})

        L = list(cf.items("section"))

        L.sort()

        self.assertEqual(L, expected)

class ConfigParserTestCase(TestCaseBase):

    config_class = ConfigParser.ConfigParser

    def test_interpolation(self):

        cf = self.get_interpolation_config()

        eq = self.assertEqual

        eq(cf.get("Foo", "getname"), "Foo")

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

        self.get_error(ConfigParser.InterpolationDepthError, "Foo", "bar11")

    def test_interpolation_missing_value(self):

        cf = self.get_interpolation_config()

        e = self.get_error(ConfigParser.InterpolationError,

                           "Interpolation Error", "name")

        self.assertEqual(e.reference, "reference")

        self.assertEqual(e.section, "Interpolation Error")

        self.assertEqual(e.option, "name")

    def test_items(self):

        self.check_items_config([('default', '<default>'),

                                 ('getdefault', '|<default>|'),

                                 ('getname', '|section|'),

                                 ('key', '|value|'),

                                 ('name', 'value')])

    def test_set_nonstring_types(self):

        cf = self.newconfig()

        cf.add_section('non-string')

        cf.set('non-string', 'int', 1)

        cf.set('non-string', 'list', [0, 1, 1, 2, 3, 5, 8, 13, '%('])

        cf.set('non-string', 'dict', {'pi': 3.14159, '%(': 1,

                                      '%(list)': '%(list)'})

        cf.set('non-string', 'string_with_interpolation', '%(list)s')

        self.assertEqual(cf.get('non-string', 'int', raw=True), 1)

        self.assertRaises(TypeError, cf.get, 'non-string', 'int')

        self.assertEqual(cf.get('non-string', 'list', raw=True),

                         [0, 1, 1, 2, 3, 5, 8, 13, '%('])

        self.assertRaises(TypeError, cf.get, 'non-string', 'list')

        self.assertEqual(cf.get('non-string', 'dict', raw=True),

                         {'pi': 3.14159, '%(': 1, '%(list)': '%(list)'})

        self.assertRaises(TypeError, cf.get, 'non-string', 'dict')

        self.assertEqual(cf.get('non-string', 'string_with_interpolation',

                                raw=True), '%(list)s')

        self.assertRaises(ValueError, cf.get, 'non-string',

                          'string_with_interpolation', raw=False)

class RawConfigParserTestCase(TestCaseBase):

    config_class = ConfigParser.RawConfigParser

    def test_interpolation(self):

        cf = self.get_interpolation_config()

        eq = self.assertEqual

        eq(cf.get("Foo", "getname"), "%(__name__)s")

        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"),

           "something %(with10)s lots of interpolation (10 steps)")

        eq(cf.get("Foo", "bar11"),

           "something %(with11)s lots of interpolation (11 steps)")

    def test_items(self):

        self.check_items_config([('default', '<default>'),

                                 ('getdefault', '|%(default)s|'),

                                 ('getname', '|%(__name__)s|'),

                                 ('key', '|%(name)s|'),

                                 ('name', 'value')])

    def test_set_nonstring_types(self):

        cf = self.newconfig()

        cf.add_section('non-string')

        cf.set('non-string', 'int', 1)

        cf.set('non-string', 'list', [0, 1, 1, 2, 3, 5, 8, 13])

        cf.set('non-string', 'dict', {'pi': 3.14159})

        self.assertEqual(cf.get('non-string', 'int'), 1)

        self.assertEqual(cf.get('non-string', 'list'),

                         [0, 1, 1, 2, 3, 5, 8, 13])

        self.assertEqual(cf.get('non-string', 'dict'), {'pi': 3.14159})

class SafeConfigParserTestCase(ConfigParserTestCase):

    config_class = ConfigParser.SafeConfigParser

    def test_safe_interpolation(self):

        # See http://www.python.org/sf/511737

        cf = self.fromstring("[section]\n"

                             "option1=xxx\n"

                             "option2=%(option1)s/xxx\n"

                             "ok=%(option1)s/%%s\n"

                             "not_ok=%(option2)s/%%s")

        self.assertEqual(cf.get("section", "ok"), "xxx/%s")

        self.assertEqual(cf.get("section", "not_ok"), "xxx/xxx/%s")

    def test_set_malformatted_interpolation(self):

        cf = self.fromstring("[sect]\n"

                             "option1=foo\n")

        self.assertEqual(cf.get('sect', "option1"), "foo")

        self.assertRaises(ValueError, cf.set, "sect", "option1", "%foo")

        self.assertRaises(ValueError, cf.set, "sect", "option1", "foo%")

        self.assertRaises(ValueError, cf.set, "sect", "option1", "f%oo")

        self.assertEqual(cf.get('sect', "option1"), "foo")

    def test_set_nonstring_types(self):

        cf = self.fromstring("[sect]\n"

                             "option1=foo\n")

        # Check that we get a TypeError when setting non-string values

        # in an existing section:

        self.assertRaises(TypeError, cf.set, "sect", "option1", 1)

        self.assertRaises(TypeError, cf.set, "sect", "option1", 1.0)

        self.assertRaises(TypeError, cf.set, "sect", "option1", object())

        self.assertRaises(TypeError, cf.set, "sect", "option2", 1)

        self.assertRaises(TypeError, cf.set, "sect", "option2", 1.0)

        self.assertRaises(TypeError, cf.set, "sect", "option2", object())

    def test_add_section_default_1(self):

        cf = self.newconfig()

        self.assertRaises(ValueError, cf.add_section, "default")

    def test_add_section_default_2(self):

        cf = self.newconfig()

        self.assertRaises(ValueError, cf.add_section, "DEFAULT")

class SortedTestCase(RawConfigParserTestCase):

    def newconfig(self, defaults=None):

        self.cf = self.config_class(defaults=defaults, dict_type=SortedDict)

        return self.cf

    def test_sorted(self):

        self.fromstring("[b]\n"

                        "o4=1\n"

                        "o3=2\n"

                        "o2=3\n"

                        "o1=4\n"

                        "[a]\n"

                        "k=v\n")

        output = StringIO.StringIO()

        self.cf.write(output)

        self.assertEquals(output.getvalue(),

                          "[a]\n"

                          "k = v\n\n"

                          "[b]\n"

                          "o1 = 4\n"

                          "o2 = 3\n"

                          "o3 = 2\n"

                          "o4 = 1\n\n")

def test_main():

    test_support.run_unittest(

        ConfigParserTestCase,

        RawConfigParserTestCase,

        SafeConfigParserTestCase,

        SortedTestCase

    )

if __name__ == "__main__":

    test_main()