/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_mapping.py

  • Committer: Jelmer Vernooij
  • Date: 2018-05-15 19:05:51 UTC
  • mfrom: (6968 work)
  • mto: (6973.5.1 python3-c)
  • mto: This revision was merged to the branch mainline in revision 6984.
  • Revision ID: jelmer@jelmer.uk-20180515190551-epr5abd0mtxmrehr
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/git/tests/test_mapping.py
75
75
class FileidTests(tests.TestCase):
76
76
 
77
77
    def test_escape_space(self):
78
 
        self.assertEquals("bla_s", escape_file_id("bla "))
 
78
        self.assertEqual("bla_s", escape_file_id("bla "))
79
79
 
80
80
    def test_escape_control_l(self):
81
 
        self.assertEquals("bla_c", escape_file_id("bla\x0c"))
 
81
        self.assertEqual("bla_c", escape_file_id("bla\x0c"))
82
82
 
83
83
    def test_unescape_control_l(self):
84
 
        self.assertEquals("bla\x0c", unescape_file_id("bla_c"))
 
84
        self.assertEqual("bla\x0c", unescape_file_id("bla_c"))
85
85
 
86
86
    def test_escape_underscore(self):
87
 
        self.assertEquals("bla__", escape_file_id("bla_"))
 
87
        self.assertEqual("bla__", escape_file_id("bla_"))
88
88
 
89
89
    def test_escape_underscore_space(self):
90
 
        self.assertEquals("bla___s", escape_file_id("bla_ "))
 
90
        self.assertEqual("bla___s", escape_file_id("bla_ "))
91
91
 
92
92
    def test_unescape_underscore(self):
93
 
        self.assertEquals("bla ", unescape_file_id("bla_s"))
 
93
        self.assertEqual("bla ", unescape_file_id("bla_s"))
94
94
 
95
95
    def test_unescape_underscore_space(self):
96
 
        self.assertEquals("bla _", unescape_file_id("bla_s__"))
 
96
        self.assertEqual("bla _", unescape_file_id("bla_s__"))
97
97
 
98
98
 
99
99
class TestImportCommit(tests.TestCase):
111
111
        mapping = BzrGitMappingv1()
112
112
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
113
113
            mapping.revision_id_foreign_to_bzr)
114
 
        self.assertEquals(None, roundtrip_revid)
115
 
        self.assertEquals({}, verifiers)
116
 
        self.assertEquals("Some message", rev.message)
117
 
        self.assertEquals("Committer", rev.committer)
118
 
        self.assertEquals("Author", rev.properties['author'])
119
 
        self.assertEquals(300, rev.timezone)
120
 
        self.assertEquals((), rev.parent_ids)
121
 
        self.assertEquals("5", rev.properties['author-timestamp'])
122
 
        self.assertEquals("180", rev.properties['author-timezone'])
123
 
        self.assertEquals("git-v1:" + c.id, rev.revision_id)
 
114
        self.assertEqual(None, roundtrip_revid)
 
115
        self.assertEqual({}, verifiers)
 
116
        self.assertEqual("Some message", rev.message)
 
117
        self.assertEqual("Committer", rev.committer)
 
118
        self.assertEqual("Author", rev.properties['author'])
 
119
        self.assertEqual(300, rev.timezone)
 
120
        self.assertEqual((), rev.parent_ids)
 
121
        self.assertEqual("5", rev.properties['author-timestamp'])
 
122
        self.assertEqual("180", rev.properties['author-timezone'])
 
123
        self.assertEqual("git-v1:" + c.id, rev.revision_id)
124
124
 
125
125
    def test_explicit_encoding(self):
126
126
        c = Commit()
136
136
        mapping = BzrGitMappingv1()
137
137
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
138
138
            mapping.revision_id_foreign_to_bzr)
139
 
        self.assertEquals(None, roundtrip_revid)
140
 
        self.assertEquals({}, verifiers)
141
 
        self.assertEquals(u"Authér", rev.properties['author'])
142
 
        self.assertEquals("iso8859-1", rev.properties["git-explicit-encoding"])
 
139
        self.assertEqual(None, roundtrip_revid)
 
140
        self.assertEqual({}, verifiers)
 
141
        self.assertEqual(u"Authér", rev.properties['author'])
 
142
        self.assertEqual("iso8859-1", rev.properties["git-explicit-encoding"])
143
143
        self.assertTrue("git-implicit-encoding" not in rev.properties)
144
144
 
145
145
    def test_implicit_encoding_fallback(self):
155
155
        mapping = BzrGitMappingv1()
156
156
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
157
157
            mapping.revision_id_foreign_to_bzr)
158
 
        self.assertEquals(None, roundtrip_revid)
159
 
        self.assertEquals({}, verifiers)
160
 
        self.assertEquals(u"Authér", rev.properties['author'])
161
 
        self.assertEquals("latin1", rev.properties["git-implicit-encoding"])
 
158
        self.assertEqual(None, roundtrip_revid)
 
159
        self.assertEqual({}, verifiers)
 
160
        self.assertEqual(u"Authér", rev.properties['author'])
 
161
        self.assertEqual("latin1", rev.properties["git-implicit-encoding"])
162
162
        self.assertTrue("git-explicit-encoding" not in rev.properties)
163
163
 
164
164
    def test_implicit_encoding_utf8(self):
174
174
        mapping = BzrGitMappingv1()
175
175
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
176
176
            mapping.revision_id_foreign_to_bzr)
177
 
        self.assertEquals(None, roundtrip_revid)
178
 
        self.assertEquals({}, verifiers)
179
 
        self.assertEquals(u"Authér", rev.properties['author'])
 
177
        self.assertEqual(None, roundtrip_revid)
 
178
        self.assertEqual({}, verifiers)
 
179
        self.assertEqual(u"Authér", rev.properties['author'])
180
180
        self.assertTrue("git-explicit-encoding" not in rev.properties)
181
181
        self.assertTrue("git-implicit-encoding" not in rev.properties)
182
182
 
230
230
            self._lookup_parent, True, "testamentsha")
231
231
        rev, roundtrip_revid, verifiers = self.mapping.import_commit(
232
232
            commit, self.mapping.revision_id_foreign_to_bzr)
233
 
        self.assertEquals(rev.revision_id,
 
233
        self.assertEqual(rev.revision_id,
234
234
            self.mapping.revision_id_foreign_to_bzr(commit.id))
235
235
        if self.mapping.roundtripping:
236
 
            self.assertEquals({"testament3-sha1": "testamentsha"} , verifiers)
237
 
            self.assertEquals(orig_rev.revision_id, roundtrip_revid)
238
 
            self.assertEquals(orig_rev.properties, rev.properties)
239
 
            self.assertEquals(orig_rev.committer, rev.committer)
240
 
            self.assertEquals(orig_rev.timestamp, rev.timestamp)
241
 
            self.assertEquals(orig_rev.timezone, rev.timezone)
242
 
            self.assertEquals(orig_rev.message, rev.message)
243
 
            self.assertEquals(list(orig_rev.parent_ids), list(rev.parent_ids))
 
236
            self.assertEqual({"testament3-sha1": "testamentsha"} , verifiers)
 
237
            self.assertEqual(orig_rev.revision_id, roundtrip_revid)
 
238
            self.assertEqual(orig_rev.properties, rev.properties)
 
239
            self.assertEqual(orig_rev.committer, rev.committer)
 
240
            self.assertEqual(orig_rev.timestamp, rev.timestamp)
 
241
            self.assertEqual(orig_rev.timezone, rev.timezone)
 
242
            self.assertEqual(orig_rev.message, rev.message)
 
243
            self.assertEqual(list(orig_rev.parent_ids), list(rev.parent_ids))
244
244
        else:
245
 
            self.assertEquals({}, verifiers)
 
245
            self.assertEqual({}, verifiers)
246
246
 
247
247
    def test_simple_commit(self):
248
248
        r = Revision(self.mapping.revision_id_foreign_to_bzr("edf99e6c56495c620f20d5dacff9859ff7119261"))
302
302
            commit1, self.mapping.revision_id_foreign_to_bzr)
303
303
        commit2 = self.mapping.export_commit(rev, "12341212121212", None,
304
304
            True, None)
305
 
        self.assertEquals(commit1.committer, commit2.committer)
306
 
        self.assertEquals(commit1.commit_time, commit2.commit_time)
307
 
        self.assertEquals(commit1.commit_timezone, commit2.commit_timezone)
308
 
        self.assertEquals(commit1.author, commit2.author)
309
 
        self.assertEquals(commit1.author_time, commit2.author_time)
310
 
        self.assertEquals(commit1.author_timezone, commit2.author_timezone)
311
 
        self.assertEquals(commit1.message, commit2.message)
312
 
        self.assertEquals(commit1.encoding, commit2.encoding)
 
305
        self.assertEqual(commit1.committer, commit2.committer)
 
306
        self.assertEqual(commit1.commit_time, commit2.commit_time)
 
307
        self.assertEqual(commit1.commit_timezone, commit2.commit_timezone)
 
308
        self.assertEqual(commit1.author, commit2.author)
 
309
        self.assertEqual(commit1.author_time, commit2.author_time)
 
310
        self.assertEqual(commit1.author_timezone, commit2.author_timezone)
 
311
        self.assertEqual(commit1.message, commit2.message)
 
312
        self.assertEqual(commit1.encoding, commit2.encoding)
313
313
 
314
314
    def test_commit(self):
315
315
        c = Commit()