~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_conflicts.py

More cleanup.

Show diffs side-by-side

added added

removed removed

Lines of Context:
23
23
    errors,
24
24
    tests,
25
25
    )
26
 
from bzrlib.conflicts import (
27
 
    ConflictList,
28
 
    ContentsConflict,
29
 
    DuplicateID,
30
 
    DuplicateEntry,
31
 
    MissingParent,
32
 
    NonDirectoryParent,
33
 
    ParentLoop,
34
 
    PathConflict,
35
 
    TextConflict,
36
 
    UnversionedParent,
37
 
    resolve,
38
 
    restore,
39
 
    )
40
26
 
41
27
 
42
28
# TODO: Test commit with some added, and added-but-missing files
105
91
 
106
92
    def test_conflicts(self):
107
93
        """Conflicts are detected properly"""
108
 
        tree = self.make_branch_and_tree('.',
109
 
            format=bzrdir.BzrDirFormat6())
110
 
        file('hello', 'w').write('hello world4')
111
 
        file('hello.THIS', 'w').write('hello world2')
112
 
        file('hello.BASE', 'w').write('hello world1')
113
 
        file('hello.OTHER', 'w').write('hello world3')
114
 
        file('hello.sploo.BASE', 'w').write('yellow world')
115
 
        file('hello.sploo.OTHER', 'w').write('yellow world2')
 
94
        # Use BzrDirFormat6 so we can fake conflicts
 
95
        tree = self.make_branch_and_tree('.', format=bzrdir.BzrDirFormat6())
 
96
        self.build_tree_contents([('hello', 'hello world4'),
 
97
                                  ('hello.THIS', 'hello world2'),
 
98
                                  ('hello.BASE', 'hello world1'),
 
99
                                  ('hello.OTHER', 'hello world3'),
 
100
                                  ('hello.sploo.BASE', 'yellowworld'),
 
101
                                  ('hello.sploo.OTHER', 'yellowworld2'),
 
102
                                  ])
116
103
        tree.lock_read()
117
104
        self.assertEqual(6, len(list(tree.list_files())))
118
105
        tree.unlock()
119
 
        conflicts = tree.conflicts()
120
 
        self.assertEqual(2, len(conflicts))
121
 
        self.assert_('hello' in conflicts[0].path)
122
 
        self.assert_('hello.sploo' in conflicts[1].path)
123
 
        restore('hello')
124
 
        restore('hello.sploo')
 
106
        tree_conflicts = tree.conflicts()
 
107
        self.assertEqual(2, len(tree_conflicts))
 
108
        self.assertTrue('hello' in tree_conflicts[0].path)
 
109
        self.assertTrue('hello.sploo' in tree_conflicts[1].path)
 
110
        conflicts.restore('hello')
 
111
        conflicts.restore('hello.sploo')
125
112
        self.assertEqual(0, len(tree.conflicts()))
126
113
        self.assertFileEqual('hello world2', 'hello')
127
114
        self.assertFalse(os.path.lexists('hello.sploo'))
128
 
        self.assertRaises(errors.NotConflicted, restore, 'hello')
129
 
        self.assertRaises(errors.NotConflicted, restore, 'hello.sploo')
 
115
        self.assertRaises(errors.NotConflicted, conflicts.restore, 'hello')
 
116
        self.assertRaises(errors.NotConflicted,
 
117
                          conflicts.restore, 'hello.sploo')
130
118
 
131
119
    def test_resolve_conflict_dir(self):
132
120
        tree = self.make_branch_and_tree('.')
133
 
        file('hello', 'w').write('hello world4')
 
121
        self.build_tree_contents([('hello', 'hello world4'),
 
122
                                  ('hello.THIS', 'hello world2'),
 
123
                                  ('hello.BASE', 'hello world1'),
 
124
                                  ])
 
125
        os.mkdir('hello.OTHER')
134
126
        tree.add('hello', 'q')
135
 
        file('hello.THIS', 'w').write('hello world2')
136
 
        file('hello.BASE', 'w').write('hello world1')
137
 
        os.mkdir('hello.OTHER')
138
 
        l = ConflictList([TextConflict('hello')])
 
127
        l = conflicts.ConflictList([conflicts.TextConflict('hello')])
139
128
        l.remove_files(tree)
140
129
 
141
130
    def test_select_conflicts(self):
142
131
        tree = self.make_branch_and_tree('.')
143
 
        tree_conflicts = conflicts.ConflictList(
144
 
            [conflicts.ContentsConflict('foo'),
145
 
             conflicts.ContentsConflict('bar')])
146
 
        self.assertEqual(
147
 
            (conflicts.ConflictList([conflicts.ContentsConflict('bar')]),
148
 
             conflicts.ConflictList([conflicts.ContentsConflict('foo')])),
149
 
            tree_conflicts.select_conflicts(tree, ['foo']))
150
 
        self.assertEqual((conflicts.ConflictList(), tree_conflicts),
151
 
                         tree_conflicts.select_conflicts(tree, [''],
152
 
                         ignore_misses=True, recurse=True))
153
 
        tree_conflicts = conflicts.ConflictList(
154
 
            [conflicts.ContentsConflict('foo/baz'),
155
 
             conflicts.ContentsConflict('bar')])
156
 
        self.assertEqual(
157
 
            (conflicts.ConflictList([conflicts.ContentsConflict('bar')]),
158
 
             conflicts.ConflictList([conflicts.ContentsConflict('foo/baz')])),
159
 
            tree_conflicts.select_conflicts(tree, ['foo'],
160
 
                                            recurse=True,
161
 
                                            ignore_misses=True))
162
 
        tree_conflicts = conflicts.ConflictList(
163
 
            [conflicts.PathConflict('qux', 'foo/baz')])
164
 
        self.assertEqual((conflicts.ConflictList(), tree_conflicts),
165
 
                         tree_conflicts.select_conflicts(tree, ['foo'],
166
 
                                                         recurse=True,
167
 
                                                         ignore_misses=True))
168
 
        self.assertEqual((tree_conflicts, conflicts.ConflictList()),
169
 
                         tree_conflicts.select_conflicts(tree, ['foo'],
170
 
                                                         ignore_misses=True))
 
132
        clist = conflicts.ConflictList
 
133
 
 
134
        def check_select(not_selected, selected, paths, **kwargs):
 
135
            self.assertEqual(
 
136
                (not_selected, selected),
 
137
                tree_conflicts.select_conflicts(tree, paths, **kwargs))
 
138
 
 
139
        foo = conflicts.ContentsConflict('foo')
 
140
        bar = conflicts.ContentsConflict('bar')
 
141
        tree_conflicts = clist([foo, bar])
 
142
 
 
143
        check_select(clist([bar]), clist([foo]), ['foo'])
 
144
        check_select(clist(), tree_conflicts,
 
145
                     [''], ignore_misses=True, recurse=True)
 
146
 
 
147
        foobaz  = conflicts.ContentsConflict('foo/baz')
 
148
        tree_conflicts = clist([foobaz, bar])
 
149
 
 
150
        check_select(clist([bar]), clist([foobaz]),
 
151
                     ['foo'], ignore_misses=True, recurse=True)
 
152
 
 
153
        qux = conflicts.PathConflict('qux', 'foo/baz')
 
154
        tree_conflicts = clist([qux])
 
155
 
 
156
        check_select(clist(), tree_conflicts,
 
157
                     ['foo'], ignore_misses=True, recurse=True)
 
158
        check_select (tree_conflicts, clist(), ['foo'], ignore_misses=True)
171
159
 
172
160
    def test_resolve_conflicts_recursive(self):
173
161
        tree = self.make_branch_and_tree('.')
174
162
        self.build_tree(['dir/', 'dir/hello'])
175
163
        tree.add(['dir', 'dir/hello'])
176
 
        tree.set_conflicts(conflicts.ConflictList(
177
 
                [conflicts.TextConflict('dir/hello')]))
178
 
        resolve(tree, ['dir'], recursive=False, ignore_misses=True)
179
 
        self.assertEqual(conflicts.ConflictList(
180
 
                [conflicts.TextConflict('dir/hello')]),
181
 
                         tree.conflicts())
182
 
        resolve(tree, ['dir'], recursive=True, ignore_misses=True)
183
 
        self.assertEqual(conflicts.ConflictList([]),
184
 
                         tree.conflicts())
 
164
 
 
165
        dirhello = conflicts.ConflictList([conflicts.TextConflict('dir/hello')])
 
166
        tree.set_conflicts(dirhello)
 
167
 
 
168
        conflicts.resolve(tree, ['dir'], recursive=False, ignore_misses=True)
 
169
        self.assertEqual(dirhello, tree.conflicts())
 
170
 
 
171
        conflicts.resolve(tree, ['dir'], recursive=True, ignore_misses=True)
 
172
        self.assertEqual(conflicts.ConflictList([]), tree.conflicts())
185
173
 
186
174