/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/plugins/git/tests/test_roundtrip.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-05-15 18:47:57 UTC
  • mfrom: (6964.2.7 python3-git)
  • Revision ID: breezy.the.bot@gmail.com-20180515184757-xozniaj9gztgtom8
Port some of brz-git to python3.

Merged from https://code.launchpad.net/~jelmer/brz/python3-git/+merge/345479

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/git/tests/test_roundtrip.py
36
36
class RoundtripTests(TestCase):
37
37
 
38
38
    def test_revid(self):
39
 
        md = parse_roundtripping_metadata("revision-id: foo\n")
40
 
        self.assertEquals("foo", md.revision_id)
 
39
        md = parse_roundtripping_metadata(b"revision-id: foo\n")
 
40
        self.assertEqual(b"foo", md.revision_id)
41
41
 
42
42
    def test_parent_ids(self):
43
 
        md = parse_roundtripping_metadata("parent-ids: foo bar\n")
44
 
        self.assertEquals(("foo", "bar"), md.explicit_parent_ids)
 
43
        md = parse_roundtripping_metadata(b"parent-ids: foo bar\n")
 
44
        self.assertEqual((b"foo", b"bar"), md.explicit_parent_ids)
45
45
 
46
46
    def test_properties(self):
47
 
        md = parse_roundtripping_metadata("property-foop: blar\n")
48
 
        self.assertEquals({"foop": "blar"}, md.properties)
 
47
        md = parse_roundtripping_metadata(b"property-foop: blar\n")
 
48
        self.assertEqual({b"foop": b"blar"}, md.properties)
49
49
 
50
50
 
51
51
class FormatTests(TestCase):
52
52
 
53
53
    def test_revid(self):
54
54
        metadata = CommitSupplement()
55
 
        metadata.revision_id = "bla"
56
 
        self.assertEquals("revision-id: bla\n",
 
55
        metadata.revision_id = b"bla"
 
56
        self.assertEqual(b"revision-id: bla\n",
57
57
            generate_roundtripping_metadata(metadata, "utf-8"))
58
58
 
59
59
    def test_parent_ids(self):
60
60
        metadata = CommitSupplement()
61
 
        metadata.explicit_parent_ids = ("foo", "bar")
62
 
        self.assertEquals("parent-ids: foo bar\n",
 
61
        metadata.explicit_parent_ids = (b"foo", b"bar")
 
62
        self.assertEqual(b"parent-ids: foo bar\n",
63
63
            generate_roundtripping_metadata(metadata, "utf-8"))
64
64
 
65
65
    def test_properties(self):
66
66
        metadata = CommitSupplement()
67
 
        metadata.properties = {"foo": "bar"}
68
 
        self.assertEquals("property-foo: bar\n",
 
67
        metadata.properties = {b"foo": b"bar"}
 
68
        self.assertEqual(b"property-foo: bar\n",
69
69
            generate_roundtripping_metadata(metadata, "utf-8"))
70
70
 
71
71
    def test_empty(self):
72
72
        metadata = CommitSupplement()
73
 
        self.assertEquals("",
 
73
        self.assertEqual(b"",
74
74
            generate_roundtripping_metadata(metadata, "utf-8"))
75
75
 
76
76
 
77
77
class ExtractMetadataTests(TestCase):
78
78
 
79
79
    def test_roundtrip(self):
80
 
        (msg, metadata) = extract_bzr_metadata("""Foo
 
80
        (msg, metadata) = extract_bzr_metadata(b"""Foo
81
81
--BZR--
82
82
revision-id: foo
83
83
""")
84
 
        self.assertEquals("Foo", msg)
85
 
        self.assertEquals("foo", metadata.revision_id)
 
84
        self.assertEqual(b"Foo", msg)
 
85
        self.assertEqual(b"foo", metadata.revision_id)
86
86
 
87
87
 
88
88
class GenerateMetadataTests(TestCase):
89
89
 
90
90
    def test_roundtrip(self):
91
91
        metadata = CommitSupplement()
92
 
        metadata.revision_id = "myrevid"
93
 
        msg = inject_bzr_metadata("Foo", metadata, "utf-8")
94
 
        self.assertEquals("""Foo
 
92
        metadata.revision_id = b"myrevid"
 
93
        msg = inject_bzr_metadata(b"Foo", metadata, "utf-8")
 
94
        self.assertEqual(b"""Foo
95
95
--BZR--
96
96
revision-id: myrevid
97
97
""", msg)
98
98
 
99
99
    def test_no_metadata(self):
100
100
        metadata = CommitSupplement()
101
 
        msg = inject_bzr_metadata("Foo", metadata, "utf-8")
102
 
        self.assertEquals("Foo", msg)
 
101
        msg = inject_bzr_metadata(b"Foo", metadata, "utf-8")
 
102
        self.assertEqual(b"Foo", msg)
103
103
 
104
104
 
105
105
class FileIdRoundTripTests(TestCase):
106
106
 
107
107
    def test_deserialize(self):
108
 
        self.assertEquals({"bar/bla": "fid"},
109
 
            deserialize_fileid_map("bar/bla\0fid\n"))
 
108
        self.assertEqual({"bar/bla": b"fid"},
 
109
            deserialize_fileid_map(b"bar/bla\0fid\n"))
110
110
 
111
111
    def test_serialize(self):
112
 
        self.assertEquals(["bar/bla\0fid\n"],
113
 
            serialize_fileid_map({"bar/bla": "fid"}))
 
112
        self.assertEqual([b"bar/bla\0fid\n"],
 
113
            serialize_fileid_map({"bar/bla": b"fid"}))
114
114