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

  • Committer: Jelmer Vernooij
  • Date: 2020-08-10 15:00:17 UTC
  • mfrom: (7490.40.99 work)
  • mto: This revision was merged to the branch mainline in revision 7521.
  • Revision ID: jelmer@jelmer.uk-20200810150017-vs7xnrd1vat4iktg
Merge lp:brz/3.1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_conflicts.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
 
18
17
import os
19
18
 
20
19
from .. import (
25
24
    tests,
26
25
    transform,
27
26
    )
28
 
from ..sixish import text_type
 
27
from ..bzr import conflicts as bzr_conflicts
29
28
from . import (
30
29
    script,
31
30
    scenarios,
43
42
# u'\xe5' == a with circle
44
43
# '\xc3\xae' == u'\xee' == i with hat
45
44
# So these are u'path' and 'id' only with a circle and a hat. (shappo?)
46
 
example_conflicts = conflicts.ConflictList(
47
 
    [conflicts.MissingParent('Not deleting', u'p\xe5thg', b'\xc3\xaedg'),
48
 
     conflicts.ContentsConflict(u'p\xe5tha', None, b'\xc3\xaeda'),
49
 
     conflicts.TextConflict(u'p\xe5tha'),
50
 
     conflicts.PathConflict(u'p\xe5thb', u'p\xe5thc', b'\xc3\xaedb'),
51
 
     conflicts.DuplicateID('Unversioned existing file',
52
 
                           u'p\xe5thc', u'p\xe5thc2',
53
 
                           b'\xc3\xaedc', b'\xc3\xaedc'),
54
 
     conflicts.DuplicateEntry('Moved existing file to',
55
 
                              u'p\xe5thdd.moved', u'p\xe5thd',
56
 
                              b'\xc3\xaedd', None),
57
 
     conflicts.ParentLoop('Cancelled move', u'p\xe5the', u'p\xe5th2e',
58
 
                          None, b'\xc3\xaed2e'),
59
 
     conflicts.UnversionedParent('Versioned directory',
60
 
                                 u'p\xe5thf', b'\xc3\xaedf'),
61
 
     conflicts.NonDirectoryParent('Created directory',
62
 
                                  u'p\xe5thg', b'\xc3\xaedg'),
63
 
     ])
 
45
example_conflicts = [
 
46
     bzr_conflicts.MissingParent('Not deleting', u'p\xe5thg', b'\xc3\xaedg'),
 
47
     bzr_conflicts.ContentsConflict(u'p\xe5tha', None, b'\xc3\xaeda'),
 
48
     bzr_conflicts.TextConflict(u'p\xe5tha'),
 
49
     bzr_conflicts.PathConflict(u'p\xe5thb', u'p\xe5thc', b'\xc3\xaedb'),
 
50
     bzr_conflicts.DuplicateID('Unversioned existing file',
 
51
                               u'p\xe5thc', u'p\xe5thc2',
 
52
                               b'\xc3\xaedc', b'\xc3\xaedc'),
 
53
     bzr_conflicts.DuplicateEntry('Moved existing file to',
 
54
                                  u'p\xe5thdd.moved', u'p\xe5thd',
 
55
                                  b'\xc3\xaedd', None),
 
56
     bzr_conflicts.ParentLoop('Cancelled move', u'p\xe5the', u'p\xe5th2e',
 
57
                              None, b'\xc3\xaed2e'),
 
58
     bzr_conflicts.UnversionedParent('Versioned directory',
 
59
                                     u'p\xe5thf', b'\xc3\xaedf'),
 
60
     bzr_conflicts.NonDirectoryParent('Created directory',
 
61
                                      u'p\xe5thg', b'\xc3\xaedg'),
 
62
     ]
64
63
 
65
64
 
66
65
def vary_by_conflicts():
78
77
                                  ])
79
78
        os.mkdir('hello.OTHER')
80
79
        tree.add('hello', b'q')
81
 
        l = conflicts.ConflictList([conflicts.TextConflict('hello')])
 
80
        l = conflicts.ConflictList([bzr_conflicts.TextConflict('hello')])
82
81
        l.remove_files(tree)
83
82
 
84
83
    def test_select_conflicts(self):
90
89
                (not_selected, selected),
91
90
                tree_conflicts.select_conflicts(tree, paths, **kwargs))
92
91
 
93
 
        foo = conflicts.ContentsConflict('foo')
94
 
        bar = conflicts.ContentsConflict('bar')
 
92
        foo = bzr_conflicts.ContentsConflict('foo')
 
93
        bar = bzr_conflicts.ContentsConflict('bar')
95
94
        tree_conflicts = clist([foo, bar])
96
95
 
97
96
        check_select(clist([bar]), clist([foo]), ['foo'])
98
97
        check_select(clist(), tree_conflicts,
99
98
                     [''], ignore_misses=True, recurse=True)
100
99
 
101
 
        foobaz = conflicts.ContentsConflict('foo/baz')
 
100
        foobaz = bzr_conflicts.ContentsConflict('foo/baz')
102
101
        tree_conflicts = clist([foobaz, bar])
103
102
 
104
103
        check_select(clist([bar]), clist([foobaz]),
105
104
                     ['foo'], ignore_misses=True, recurse=True)
106
105
 
107
 
        qux = conflicts.PathConflict('qux', 'foo/baz')
 
106
        qux = bzr_conflicts.PathConflict('qux', 'foo/baz')
108
107
        tree_conflicts = clist([qux])
109
108
 
110
 
        check_select(clist(), tree_conflicts,
 
109
        check_select(tree_conflicts, clist(),
111
110
                     ['foo'], ignore_misses=True, recurse=True)
112
111
        check_select(tree_conflicts, clist(), ['foo'], ignore_misses=True)
113
112
 
116
115
        self.build_tree(['dir/', 'dir/hello'])
117
116
        tree.add(['dir', 'dir/hello'])
118
117
 
119
 
        dirhello = conflicts.ConflictList(
120
 
            [conflicts.TextConflict('dir/hello')])
 
118
        dirhello = [bzr_conflicts.TextConflict('dir/hello')]
121
119
        tree.set_conflicts(dirhello)
122
120
 
123
121
        conflicts.resolve(tree, ['dir'], recursive=False, ignore_misses=True)
132
130
    scenarios = scenarios.multiply_scenarios(vary_by_conflicts())
133
131
 
134
132
    def test_stringification(self):
135
 
        text = text_type(self.conflict)
 
133
        text = str(self.conflict)
136
134
        self.assertContainsString(text, self.conflict.path)
137
135
        self.assertContainsString(text.lower(), "conflict")
138
136
        self.assertContainsString(repr(self.conflict),
139
137
                                  self.conflict.__class__.__name__)
140
138
 
141
 
    def test_stanza_roundtrip(self):
142
 
        p = self.conflict
143
 
        o = conflicts.Conflict.factory(**p.as_stanza().as_dict())
144
 
        self.assertEqual(o, p)
145
 
 
146
 
        self.assertIsInstance(o.path, text_type)
147
 
 
148
 
        if o.file_id is not None:
149
 
            self.assertIsInstance(o.file_id, bytes)
150
 
 
151
 
        conflict_path = getattr(o, 'conflict_path', None)
152
 
        if conflict_path is not None:
153
 
            self.assertIsInstance(conflict_path, text_type)
154
 
 
155
 
        conflict_file_id = getattr(o, 'conflict_file_id', None)
156
 
        if conflict_file_id is not None:
157
 
            self.assertIsInstance(conflict_file_id, bytes)
158
 
 
159
 
    def test_stanzification(self):
160
 
        stanza = self.conflict.as_stanza()
161
 
        if 'file_id' in stanza:
162
 
            # In Stanza form, the file_id has to be unicode.
163
 
            self.assertStartsWith(stanza['file_id'], u'\xeed')
164
 
        self.assertStartsWith(stanza['path'], u'p\xe5th')
165
 
        if 'conflict_path' in stanza:
166
 
            self.assertStartsWith(stanza['conflict_path'], u'p\xe5th')
167
 
        if 'conflict_file_id' in stanza:
168
 
            self.assertStartsWith(stanza['conflict_file_id'], u'\xeed')
169
 
 
170
139
 
171
140
class TestConflictList(tests.TestCase):
172
141
 
173
142
    def test_stanzas_roundtrip(self):
174
 
        stanzas_iter = example_conflicts.to_stanzas()
175
 
        processed = conflicts.ConflictList.from_stanzas(stanzas_iter)
 
143
        stanzas_iter = bzr_conflicts.ConflictList(example_conflicts).to_stanzas()
 
144
        processed = bzr_conflicts.ConflictList.from_stanzas(stanzas_iter)
176
145
        self.assertEqual(example_conflicts, processed)
177
146
 
178
147
    def test_stringification(self):
179
 
        for text, o in zip(example_conflicts.to_strings(), example_conflicts):
 
148
        for text, o in zip(
 
149
                bzr_conflicts.ConflictList(example_conflicts).to_strings(),
 
150
                example_conflicts):
180
151
            self.assertEqual(text, text_type(o))
181
152
 
182
153
 
368
339
 
369
340
class TestResolveTextConflicts(TestParametrizedResolveConflicts):
370
341
 
371
 
    _conflict_type = conflicts.TextConflict
 
342
    _conflict_type = bzr_conflicts.TextConflict
372
343
 
373
344
    # Set by the scenarios
374
345
    # path and file-id for the file involved in the conflict
439
410
 
440
411
class TestResolveContentsConflict(TestParametrizedResolveConflicts):
441
412
 
442
 
    _conflict_type = conflicts.ContentsConflict
 
413
    _conflict_type = bzr_conflicts.ContentsConflict
443
414
 
444
415
    # Set by the scenarios
445
416
    # path and file-id for the file involved in the conflict
525
496
 
526
497
class TestResolvePathConflict(TestParametrizedResolveConflicts):
527
498
 
528
 
    _conflict_type = conflicts.PathConflict
 
499
    _conflict_type = bzr_conflicts.PathConflict
529
500
 
530
501
    def do_nothing(self):
531
502
        return []
675
646
        # We create a conflict object as it was created before the fix and
676
647
        # inject it into the working tree, the test will exercise the
677
648
        # compatibility code.
678
 
        old_c = conflicts.PathConflict('<deleted>', self._item_path,
 
649
        old_c = bzr_conflicts.PathConflict('<deleted>', self._item_path,
679
650
                                       file_id=None)
680
 
        wt.set_conflicts(conflicts.ConflictList([old_c]))
 
651
        wt.set_conflicts([old_c])
681
652
 
682
653
 
683
654
class TestResolveDuplicateEntry(TestParametrizedResolveConflicts):
684
655
 
685
 
    _conflict_type = conflicts.DuplicateEntry
 
656
    _conflict_type = bzr_conflicts.DuplicateEntry
686
657
 
687
658
    scenarios = mirror_scenarios(
688
659
        [
921
892
 
922
893
class TestResolveParentLoop(TestParametrizedResolveConflicts):
923
894
 
924
 
    _conflict_type = conflicts.ParentLoop
 
895
    _conflict_type = bzr_conflicts.ParentLoop
925
896
 
926
897
    _this_args = None
927
898
    _other_args = None