# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
-"""Tests for reading and writing configuraiton files."""
+"""Tests for reading and writing configuration files."""
-from cStringIO import StringIO
+from io import BytesIO
from dulwich.config import (
ConfigDict,
ConfigFile,
_parse_string,
_unescape_value,
)
-from dulwich.tests import TestCase
+from dulwich.tests import (
+ TestCase,
+ )
class ConfigFileTests(TestCase):
def from_file(self, text):
- return ConfigFile.from_file(StringIO(text))
+ return ConfigFile.from_file(BytesIO(text))
def test_empty(self):
ConfigFile()
self.assertEqual(ConfigFile(), ConfigFile())
def test_default_config(self):
- cf = self.from_file("""[core]
+ cf = self.from_file(b"""[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
""")
- self.assertEqual(ConfigFile({("core", ): {
- "repositoryformatversion": "0",
- "filemode": "true",
- "bare": "false",
- "logallrefupdates": "true"}}), cf)
+ self.assertEqual(ConfigFile({(b"core", ): {
+ b"repositoryformatversion": b"0",
+ b"filemode": b"true",
+ b"bare": b"false",
+ b"logallrefupdates": b"true"}}), cf)
def test_from_file_empty(self):
- cf = self.from_file("")
+ cf = self.from_file(b"")
self.assertEqual(ConfigFile(), cf)
def test_empty_line_before_section(self):
- cf = self.from_file("\n[section]\n")
- self.assertEqual(ConfigFile({("section", ): {}}), cf)
+ cf = self.from_file(b"\n[section]\n")
+ self.assertEqual(ConfigFile({(b"section", ): {}}), cf)
def test_comment_before_section(self):
- cf = self.from_file("# foo\n[section]\n")
- self.assertEqual(ConfigFile({("section", ): {}}), cf)
+ cf = self.from_file(b"# foo\n[section]\n")
+ self.assertEqual(ConfigFile({(b"section", ): {}}), cf)
def test_comment_after_section(self):
- cf = self.from_file("[section] # foo\n")
- self.assertEqual(ConfigFile({("section", ): {}}), cf)
+ cf = self.from_file(b"[section] # foo\n")
+ self.assertEqual(ConfigFile({(b"section", ): {}}), cf)
def test_comment_after_variable(self):
- cf = self.from_file("[section]\nbar= foo # a comment\n")
- self.assertEqual(ConfigFile({("section", ): {"bar": "foo"}}), cf)
+ cf = self.from_file(b"[section]\nbar= foo # a comment\n")
+ self.assertEqual(ConfigFile({(b"section", ): {b"bar": b"foo"}}), cf)
def test_from_file_section(self):
- cf = self.from_file("[core]\nfoo = bar\n")
- self.assertEqual("bar", cf.get(("core", ), "foo"))
- self.assertEqual("bar", cf.get(("core", "foo"), "foo"))
+ cf = self.from_file(b"[core]\nfoo = bar\n")
+ self.assertEqual(b"bar", cf.get((b"core", ), b"foo"))
+ self.assertEqual(b"bar", cf.get((b"core", b"foo"), b"foo"))
def test_from_file_section_case_insensitive(self):
- cf = self.from_file("[cOre]\nfOo = bar\n")
- self.assertEqual("bar", cf.get(("core", ), "foo"))
- self.assertEqual("bar", cf.get(("core", "foo"), "foo"))
+ cf = self.from_file(b"[cOre]\nfOo = bar\n")
+ self.assertEqual(b"bar", cf.get((b"core", ), b"foo"))
+ self.assertEqual(b"bar", cf.get((b"core", b"foo"), b"foo"))
def test_from_file_with_mixed_quoted(self):
- cf = self.from_file("[core]\nfoo = \"bar\"la\n")
- self.assertEqual("barla", cf.get(("core", ), "foo"))
+ cf = self.from_file(b"[core]\nfoo = \"bar\"la\n")
+ self.assertEqual(b"barla", cf.get((b"core", ), b"foo"))
def test_from_file_with_open_quoted(self):
self.assertRaises(ValueError,
- self.from_file, "[core]\nfoo = \"bar\n")
+ self.from_file, b"[core]\nfoo = \"bar\n")
def test_from_file_with_quotes(self):
cf = self.from_file(
- "[core]\n"
- 'foo = " bar"\n')
- self.assertEqual(" bar", cf.get(("core", ), "foo"))
+ b"[core]\n"
+ b'foo = " bar"\n')
+ self.assertEqual(b" bar", cf.get((b"core", ), b"foo"))
def test_from_file_with_interrupted_line(self):
cf = self.from_file(
- "[core]\n"
- 'foo = bar\\\n'
- ' la\n')
- self.assertEqual("barla", cf.get(("core", ), "foo"))
+ b"[core]\n"
+ b'foo = bar\\\n'
+ b' la\n')
+ self.assertEqual(b"barla", cf.get((b"core", ), b"foo"))
def test_from_file_with_boolean_setting(self):
cf = self.from_file(
- "[core]\n"
- 'foo\n')
- self.assertEqual("true", cf.get(("core", ), "foo"))
+ b"[core]\n"
+ b'foo\n')
+ self.assertEqual(b"true", cf.get((b"core", ), b"foo"))
def test_from_file_subsection(self):
- cf = self.from_file("[branch \"foo\"]\nfoo = bar\n")
- self.assertEqual("bar", cf.get(("branch", "foo"), "foo"))
+ cf = self.from_file(b"[branch \"foo\"]\nfoo = bar\n")
+ self.assertEqual(b"bar", cf.get((b"branch", b"foo"), b"foo"))
def test_from_file_subsection_invalid(self):
self.assertRaises(ValueError,
- self.from_file, "[branch \"foo]\nfoo = bar\n")
+ self.from_file, b"[branch \"foo]\nfoo = bar\n")
def test_from_file_subsection_not_quoted(self):
- cf = self.from_file("[branch.foo]\nfoo = bar\n")
- self.assertEqual("bar", cf.get(("branch", "foo"), "foo"))
+ cf = self.from_file(b"[branch.foo]\nfoo = bar\n")
+ self.assertEqual(b"bar", cf.get((b"branch", b"foo"), b"foo"))
def test_write_to_file_empty(self):
c = ConfigFile()
- f = StringIO()
+ f = BytesIO()
c.write_to_file(f)
- self.assertEqual("", f.getvalue())
+ self.assertEqual(b"", f.getvalue())
def test_write_to_file_section(self):
c = ConfigFile()
- c.set(("core", ), "foo", "bar")
- f = StringIO()
+ c.set((b"core", ), b"foo", b"bar")
+ f = BytesIO()
c.write_to_file(f)
- self.assertEqual("[core]\nfoo = bar\n", f.getvalue())
+ self.assertEqual(b"[core]\n\tfoo = bar\n", f.getvalue())
def test_write_to_file_subsection(self):
c = ConfigFile()
- c.set(("branch", "blie"), "foo", "bar")
- f = StringIO()
+ c.set((b"branch", b"blie"), b"foo", b"bar")
+ f = BytesIO()
c.write_to_file(f)
- self.assertEqual("[branch \"blie\"]\nfoo = bar\n", f.getvalue())
+ self.assertEqual(b"[branch \"blie\"]\n\tfoo = bar\n", f.getvalue())
def test_same_line(self):
- cf = self.from_file("[branch.foo] foo = bar\n")
- self.assertEqual("bar", cf.get(("branch", "foo"), "foo"))
+ cf = self.from_file(b"[branch.foo] foo = bar\n")
+ self.assertEqual(b"bar", cf.get((b"branch", b"foo"), b"foo"))
+
+ #@expectedFailure
+ def test_quoted(self):
+ cf = self.from_file(b"""[gui]
+ fontdiff = -family \\\"Ubuntu Mono\\\" -size 11 -weight normal -slant roman -underline 0 -overstrike 0
+""")
+ self.assertEqual(ConfigFile({(b'gui', ): {
+ b'fontdiff': b'-family "Ubuntu Mono" -size 11 -weight normal -slant roman -underline 0 -overstrike 0',
+ }}), cf)
class ConfigDictTests(TestCase):
def test_get_set(self):
cd = ConfigDict()
- self.assertRaises(KeyError, cd.get, "foo", "core")
- cd.set(("core", ), "foo", "bla")
- self.assertEqual("bla", cd.get(("core", ), "foo"))
- cd.set(("core", ), "foo", "bloe")
- self.assertEqual("bloe", cd.get(("core", ), "foo"))
+ self.assertRaises(KeyError, cd.get, b"foo", b"core")
+ cd.set((b"core", ), b"foo", b"bla")
+ self.assertEqual(b"bla", cd.get((b"core", ), b"foo"))
+ cd.set((b"core", ), b"foo", b"bloe")
+ self.assertEqual(b"bloe", cd.get((b"core", ), b"foo"))
def test_get_boolean(self):
cd = ConfigDict()
- cd.set(("core", ), "foo", "true")
- self.assertTrue(cd.get_boolean(("core", ), "foo"))
- cd.set(("core", ), "foo", "false")
- self.assertFalse(cd.get_boolean(("core", ), "foo"))
- cd.set(("core", ), "foo", "invalid")
- self.assertRaises(ValueError, cd.get_boolean, ("core", ), "foo")
+ cd.set((b"core", ), b"foo", b"true")
+ self.assertTrue(cd.get_boolean((b"core", ), b"foo"))
+ cd.set((b"core", ), b"foo", b"false")
+ self.assertFalse(cd.get_boolean((b"core", ), b"foo"))
+ cd.set((b"core", ), b"foo", b"invalid")
+ self.assertRaises(ValueError, cd.get_boolean, (b"core", ), b"foo")
def test_dict(self):
cd = ConfigDict()
- cd.set(("core", ), "foo", "bla")
- cd.set(("core2", ), "foo", "bloe")
+ cd.set((b"core", ), b"foo", b"bla")
+ cd.set((b"core2", ), b"foo", b"bloe")
- self.assertEqual([("core2", ), ("core", )], cd.keys())
- self.assertEqual(cd[("core", )], {'foo': 'bla'})
+ self.assertEqual([(b"core", ), (b"core2", )], list(cd.keys()))
+ self.assertEqual(cd[(b"core", )], {b'foo': b'bla'})
- cd['a'] = 'b'
- self.assertEqual(cd['a'], 'b')
+ cd[b'a'] = b'b'
+ self.assertEqual(cd[b'a'], b'b')
+ def test_iteritems(self):
+ cd = ConfigDict()
+ cd.set((b"core", ), b"foo", b"bla")
+ cd.set((b"core2", ), b"foo", b"bloe")
-class StackedConfigTests(TestCase):
+ self.assertEqual(
+ [(b'foo', b'bla')],
+ list(cd.iteritems((b"core", ))))
- def test_default_backends(self):
- StackedConfig.default_backends()
+ def test_iteritems_nonexistant(self):
+ cd = ConfigDict()
+ cd.set((b"core2", ), b"foo", b"bloe")
+ self.assertEqual([],
+ list(cd.iteritems((b"core", ))))
-class UnescapeTests(TestCase):
+ def test_itersections(self):
+ cd = ConfigDict()
+ cd.set((b"core2", ), b"foo", b"bloe")
- def test_nothing(self):
- self.assertEqual("", _unescape_value(""))
+ self.assertEqual([(b"core2", )],
+ list(cd.itersections()))
- def test_tab(self):
- self.assertEqual("\tbar\t", _unescape_value("\\tbar\\t"))
- def test_newline(self):
- self.assertEqual("\nbar\t", _unescape_value("\\nbar\\t"))
+class StackedConfigTests(TestCase):
- def test_quote(self):
- self.assertEqual("\"foo\"", _unescape_value("\\\"foo\\\""))
+ def test_default_backends(self):
+ StackedConfig.default_backends()
class EscapeValueTests(TestCase):
def test_nothing(self):
- self.assertEqual("foo", _escape_value("foo"))
+ self.assertEqual(b"foo", _escape_value(b"foo"))
def test_backslash(self):
- self.assertEqual("foo\\\\", _escape_value("foo\\"))
+ self.assertEqual(b"foo\\\\", _escape_value(b"foo\\"))
def test_newline(self):
- self.assertEqual("foo\\n", _escape_value("foo\n"))
+ self.assertEqual(b"foo\\n", _escape_value(b"foo\n"))
class FormatStringTests(TestCase):
def test_quoted(self):
- self.assertEqual('" foo"', _format_string(" foo"))
- self.assertEqual('"\\tfoo"', _format_string("\tfoo"))
+ self.assertEqual(b'" foo"', _format_string(b" foo"))
+ self.assertEqual(b'"\\tfoo"', _format_string(b"\tfoo"))
def test_not_quoted(self):
- self.assertEqual('foo', _format_string("foo"))
- self.assertEqual('foo bar', _format_string("foo bar"))
+ self.assertEqual(b'foo', _format_string(b"foo"))
+ self.assertEqual(b'foo bar', _format_string(b"foo bar"))
class ParseStringTests(TestCase):
def test_quoted(self):
- self.assertEqual(' foo', _parse_string('" foo"'))
- self.assertEqual('\tfoo', _parse_string('"\\tfoo"'))
+ self.assertEqual(b' foo', _parse_string(b'" foo"'))
+ self.assertEqual(b'\tfoo', _parse_string(b'"\\tfoo"'))
def test_not_quoted(self):
- self.assertEqual('foo', _parse_string("foo"))
- self.assertEqual('foo bar', _parse_string("foo bar"))
+ self.assertEqual(b'foo', _parse_string(b"foo"))
+ self.assertEqual(b'foo bar', _parse_string(b"foo bar"))
+
+ def test_nothing(self):
+ self.assertEqual(b"", _parse_string(b''))
+
+ def test_tab(self):
+ self.assertEqual(b"\tbar\t", _parse_string(b"\\tbar\\t"))
+
+ def test_newline(self):
+ self.assertEqual(b"\nbar\t", _parse_string(b"\\nbar\\t\t"))
+
+ def test_quote(self):
+ self.assertEqual(b"\"foo\"", _parse_string(b"\\\"foo\\\""))
class CheckVariableNameTests(TestCase):
def test_invalid(self):
- self.assertFalse(_check_variable_name("foo "))
- self.assertFalse(_check_variable_name("bar,bar"))
- self.assertFalse(_check_variable_name("bar.bar"))
+ self.assertFalse(_check_variable_name(b"foo "))
+ self.assertFalse(_check_variable_name(b"bar,bar"))
+ self.assertFalse(_check_variable_name(b"bar.bar"))
def test_valid(self):
- self.assertTrue(_check_variable_name("FOO"))
- self.assertTrue(_check_variable_name("foo"))
- self.assertTrue(_check_variable_name("foo-bar"))
+ self.assertTrue(_check_variable_name(b"FOO"))
+ self.assertTrue(_check_variable_name(b"foo"))
+ self.assertTrue(_check_variable_name(b"foo-bar"))
class CheckSectionNameTests(TestCase):
def test_invalid(self):
- self.assertFalse(_check_section_name("foo "))
- self.assertFalse(_check_section_name("bar,bar"))
+ self.assertFalse(_check_section_name(b"foo "))
+ self.assertFalse(_check_section_name(b"bar,bar"))
def test_valid(self):
- self.assertTrue(_check_section_name("FOO"))
- self.assertTrue(_check_section_name("foo"))
- self.assertTrue(_check_section_name("foo-bar"))
- self.assertTrue(_check_section_name("bar.bar"))
+ self.assertTrue(_check_section_name(b"FOO"))
+ self.assertTrue(_check_section_name(b"foo"))
+ self.assertTrue(_check_section_name(b"foo-bar"))
+ self.assertTrue(_check_section_name(b"bar.bar"))
git.samba.org / jelmer / dulwich.git / blobdiff