/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: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

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
 
 
22
20
from ...revision import (
23
21
    Revision,
24
22
    )
34
32
    )
35
33
 
36
34
from .. import tests
37
 
from ..errors import UnknownCommitExtra
38
35
from ..mapping import (
39
36
    BzrGitMappingv1,
40
37
    escape_file_id,
41
38
    fix_person_identifier,
42
39
    unescape_file_id,
 
40
    UnknownCommitExtra,
 
41
    UnknownMercurialCommitExtra,
43
42
    )
44
43
 
45
44
 
108
107
        c.author_timezone = 60 * 3
109
108
        c.author = b"Author"
110
109
        mapping = BzrGitMappingv1()
111
 
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
112
 
                                                                mapping.revision_id_foreign_to_bzr)
 
110
        rev, roundtrip_revid, verifiers = mapping.import_commit(
 
111
            c, mapping.revision_id_foreign_to_bzr)
113
112
        self.assertEqual(None, roundtrip_revid)
114
113
        self.assertEqual({}, verifiers)
115
114
        self.assertEqual(u"Some message", rev.message)
133
132
        c.author = u"Authér".encode("iso8859-1")
134
133
        c.encoding = b"iso8859-1"
135
134
        mapping = BzrGitMappingv1()
136
 
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
137
 
                                                                mapping.revision_id_foreign_to_bzr)
 
135
        rev, roundtrip_revid, verifiers = mapping.import_commit(
 
136
            c, mapping.revision_id_foreign_to_bzr)
138
137
        self.assertEqual(None, roundtrip_revid)
139
138
        self.assertEqual({}, verifiers)
140
139
        self.assertEqual(u"Authér", rev.properties[u'author'])
152
151
        c.author_timezone = 60 * 3
153
152
        c.author = u"Authér".encode("latin1")
154
153
        mapping = BzrGitMappingv1()
155
 
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
156
 
                                                                mapping.revision_id_foreign_to_bzr)
 
154
        rev, roundtrip_revid, verifiers = mapping.import_commit(
 
155
            c, mapping.revision_id_foreign_to_bzr)
157
156
        self.assertEqual(None, roundtrip_revid)
158
157
        self.assertEqual({}, verifiers)
159
158
        self.assertEqual(u"Authér", rev.properties[u'author'])
171
170
        c.author_timezone = 60 * 3
172
171
        c.author = u"Authér".encode("utf-8")
173
172
        mapping = BzrGitMappingv1()
174
 
        rev, roundtrip_revid, verifiers = mapping.import_commit(c,
175
 
                                                                mapping.revision_id_foreign_to_bzr)
 
173
        rev, roundtrip_revid, verifiers = mapping.import_commit(
 
174
            c, mapping.revision_id_foreign_to_bzr)
176
175
        self.assertEqual(None, roundtrip_revid)
177
176
        self.assertEqual({}, verifiers)
178
177
        self.assertEqual(u"Authér", rev.properties[u'author'])
193
192
        mapping = BzrGitMappingv1()
194
193
        self.assertRaises(UnknownCommitExtra, mapping.import_commit, c,
195
194
                          mapping.revision_id_foreign_to_bzr)
 
195
        mapping.import_commit(c, mapping.revision_id_foreign_to_bzr, strict=False)
196
196
 
197
197
    def test_mergetag(self):
198
198
        c = Commit()
217
217
        self.assertEqual(
218
218
            rev.properties[u'git-mergetag-0'], tag.as_raw_string())
219
219
 
 
220
    def test_unknown_hg_fields(self):
 
221
        c = Commit()
 
222
        c.tree = b"cc9462f7f8263ef5adfbeff2fb936bb36b504cba"
 
223
        c.message = b"Some message"
 
224
        c.committer = b"Committer"
 
225
        c.commit_time = 4
 
226
        c.author_time = 5
 
227
        c.commit_timezone = 60 * 5
 
228
        c.author_timezone = 60 * 3
 
229
        c.author = b"Author"
 
230
        c._extra = [(b"HG:extra", b"bla:Foo")]
 
231
        mapping = BzrGitMappingv1()
 
232
        self.assertRaises(
 
233
            UnknownMercurialCommitExtra,
 
234
            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
        self.assertEqual(
 
253
            mapping.revision_id_foreign_to_bzr(c.id),
 
254
            mapping.get_revision_id(c))
 
255
 
220
256
 
221
257
class RoundtripRevisionsFromBazaar(tests.TestCase):
222
258
 
230
266
        commit = self.mapping.export_commit(orig_rev, b"mysha",
231
267
                                            self._lookup_parent, True, b"testamentsha")
232
268
        rev, roundtrip_revid, verifiers = self.mapping.import_commit(
233
 
            commit, self.mapping.revision_id_foreign_to_bzr)
 
269
            commit, self.mapping.revision_id_foreign_to_bzr, strict=True)
234
270
        self.assertEqual(rev.revision_id,
235
271
                         self.mapping.revision_id_foreign_to_bzr(commit.id))
236
272
        if self.mapping.roundtripping:
301
337
 
302
338
    def assertRoundtripCommit(self, commit1):
303
339
        rev, roundtrip_revid, verifiers = self.mapping.import_commit(
304
 
            commit1, self.mapping.revision_id_foreign_to_bzr)
 
340
            commit1, self.mapping.revision_id_foreign_to_bzr, strict=True)
305
341
        commit2 = self.mapping.export_commit(rev, "12341212121212", None,
306
342
                                             True, None)
307
343
        self.assertEqual(commit1.committer, commit2.committer)
405
441
                         fix_person_identifier(b"bar@blah.nl"))
406
442
 
407
443
    def test_fix(self):
408
 
        self.assertEqual(b"person <bar@blah.nl>",
409
 
                         fix_person_identifier(b"somebody <person <bar@blah.nl>>"))
410
 
        self.assertEqual(b"person <bar@blah.nl>",
411
 
                         fix_person_identifier(b"person<bar@blah.nl>"))
 
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'))
412
453
        self.assertRaises(ValueError,
413
454
                          fix_person_identifier, b"person >bar@blah.nl<")