/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/git/tests/test_mapping.py

  • Committer: Jelmer Vernooij
  • Date: 2019-03-05 07:32:38 UTC
  • mto: (7290.1.21 work)
  • mto: This revision was merged to the branch mainline in revision 7311.
  • Revision ID: jelmer@jelmer.uk-20190305073238-zlqn981opwnqsmzi
Add appveyor configuration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/tests/test_mapping.py
17
17
 
18
18
"""Tests for mapping."""
19
19
 
 
20
from __future__ import absolute_import
 
21
 
20
22
from ...revision import (
21
23
    Revision,
22
24
    )
32
34
    )
33
35
 
34
36
from .. import tests
 
37
from ..errors import (
 
38
    UnknownCommitExtra,
 
39
    UnknownMercurialCommitExtra,
 
40
    )
35
41
from ..mapping import (
36
42
    BzrGitMappingv1,
37
43
    escape_file_id,
38
44
    fix_person_identifier,
39
45
    unescape_file_id,
40
 
    UnknownCommitExtra,
41
 
    UnknownMercurialCommitExtra,
42
46
    )
43
47
 
44
48
 
107
111
        c.author_timezone = 60 * 3
108
112
        c.author = b"Author"
109
113
        mapping = BzrGitMappingv1()
110
 
        rev, roundtrip_revid, verifiers = mapping.import_commit(
111
 
            c, mapping.revision_id_foreign_to_bzr)
 
114
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
 
115
                                                                mapping.revision_id_foreign_to_bzr)
112
116
        self.assertEqual(None, roundtrip_revid)
113
117
        self.assertEqual({}, verifiers)
114
118
        self.assertEqual(u"Some message", rev.message)
132
136
        c.author = u"Authér".encode("iso8859-1")
133
137
        c.encoding = b"iso8859-1"
134
138
        mapping = BzrGitMappingv1()
135
 
        rev, roundtrip_revid, verifiers = mapping.import_commit(
136
 
            c, mapping.revision_id_foreign_to_bzr)
 
139
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
 
140
                                                                mapping.revision_id_foreign_to_bzr)
137
141
        self.assertEqual(None, roundtrip_revid)
138
142
        self.assertEqual({}, verifiers)
139
143
        self.assertEqual(u"Authér", rev.properties[u'author'])
151
155
        c.author_timezone = 60 * 3
152
156
        c.author = u"Authér".encode("latin1")
153
157
        mapping = BzrGitMappingv1()
154
 
        rev, roundtrip_revid, verifiers = mapping.import_commit(
155
 
            c, mapping.revision_id_foreign_to_bzr)
 
158
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
 
159
                                                                mapping.revision_id_foreign_to_bzr)
156
160
        self.assertEqual(None, roundtrip_revid)
157
161
        self.assertEqual({}, verifiers)
158
162
        self.assertEqual(u"Authér", rev.properties[u'author'])
170
174
        c.author_timezone = 60 * 3
171
175
        c.author = u"Authér".encode("utf-8")
172
176
        mapping = BzrGitMappingv1()
173
 
        rev, roundtrip_revid, verifiers = mapping.import_commit(
174
 
            c, mapping.revision_id_foreign_to_bzr)
 
177
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
 
178
                                                                mapping.revision_id_foreign_to_bzr)
175
179
        self.assertEqual(None, roundtrip_revid)
176
180
        self.assertEqual({}, verifiers)
177
181
        self.assertEqual(u"Authér", rev.properties[u'author'])
192
196
        mapping = BzrGitMappingv1()
193
197
        self.assertRaises(UnknownCommitExtra, mapping.import_commit, c,
194
198
                          mapping.revision_id_foreign_to_bzr)
195
 
        mapping.import_commit(c, mapping.revision_id_foreign_to_bzr, strict=False)
196
199
 
197
200
    def test_mergetag(self):
198
201
        c = Commit()
232
235
        self.assertRaises(
233
236
            UnknownMercurialCommitExtra,
234
237
            mapping.import_commit, c, mapping.revision_id_foreign_to_bzr)
235
 
        mapping.import_commit(
236
 
            c, mapping.revision_id_foreign_to_bzr, strict=False)
237
 
        self.assertEqual(
238
 
            mapping.revision_id_foreign_to_bzr(c.id),
239
 
            mapping.get_revision_id(c))
240
 
 
241
 
    def test_invalid_utf8(self):
242
 
        c = Commit()
243
 
        c.tree = b"cc9462f7f8263ef5adfbeff2fb936bb36b504cba"
244
 
        c.message = b"Some message \xc1"
245
 
        c.committer = b"Committer"
246
 
        c.commit_time = 4
247
 
        c.author_time = 5
248
 
        c.commit_timezone = 60 * 5
249
 
        c.author_timezone = 60 * 3
250
 
        c.author = b"Author"
251
 
        mapping = BzrGitMappingv1()
252
238
        self.assertEqual(
253
239
            mapping.revision_id_foreign_to_bzr(c.id),
254
240
            mapping.get_revision_id(c))
266
252
        commit = self.mapping.export_commit(orig_rev, b"mysha",
267
253
                                            self._lookup_parent, True, b"testamentsha")
268
254
        rev, roundtrip_revid, verifiers = self.mapping.import_commit(
269
 
            commit, self.mapping.revision_id_foreign_to_bzr, strict=True)
 
255
            commit, self.mapping.revision_id_foreign_to_bzr)
270
256
        self.assertEqual(rev.revision_id,
271
257
                         self.mapping.revision_id_foreign_to_bzr(commit.id))
272
258
        if self.mapping.roundtripping:
337
323
 
338
324
    def assertRoundtripCommit(self, commit1):
339
325
        rev, roundtrip_revid, verifiers = self.mapping.import_commit(
340
 
            commit1, self.mapping.revision_id_foreign_to_bzr, strict=True)
 
326
            commit1, self.mapping.revision_id_foreign_to_bzr)
341
327
        commit2 = self.mapping.export_commit(rev, "12341212121212", None,
342
328
                                             True, None)
343
329
        self.assertEqual(commit1.committer, commit2.committer)
441
427
                         fix_person_identifier(b"bar@blah.nl"))
442
428
 
443
429
    def test_fix(self):
444
 
        self.assertEqual(
445
 
            b"person <bar@blah.nl>",
446
 
            fix_person_identifier(b"somebody <person <bar@blah.nl>>"))
447
 
        self.assertEqual(
448
 
            b"person <bar@blah.nl>",
449
 
            fix_person_identifier(b"person<bar@blah.nl>"))
450
 
        self.assertEqual(
451
 
            b'Rohan Garg <rohangarg@kubuntu.org>',
452
 
            fix_person_identifier(b'Rohan Garg <rohangarg@kubuntu.org'))
 
430
        self.assertEqual(b"person <bar@blah.nl>",
 
431
                         fix_person_identifier(b"somebody <person <bar@blah.nl>>"))
 
432
        self.assertEqual(b"person <bar@blah.nl>",
 
433
                         fix_person_identifier(b"person<bar@blah.nl>"))
453
434
        self.assertRaises(ValueError,
454
435
                          fix_person_identifier, b"person >bar@blah.nl<")