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

  • Committer: Jelmer Vernooij
  • Date: 2019-01-01 21:08:01 UTC
  • mto: This revision was merged to the branch mainline in revision 7231.
  • Revision ID: jelmer@jelmer.uk-20190101210801-2dlsv7b1lvydmpkl
Fix tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/per_merger.py
 
1
# Copyright (C) 2009, 2010, 2011 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Implementation tests for breezy.merge.Merger."""
 
18
 
 
19
import os
 
20
 
 
21
from ..conflicts import TextConflict
 
22
from .. import (
 
23
    errors,
 
24
    merge as _mod_merge,
 
25
    )
 
26
from . import (
 
27
    multiply_tests,
 
28
    TestCaseWithTransport,
 
29
    )
 
30
from .test_merge_core import MergeBuilder
 
31
from ..transform import TreeTransform
 
32
 
 
33
 
 
34
def load_tests(loader, standard_tests, pattern):
 
35
    """Multiply tests for tranport implementations."""
 
36
    result = loader.suiteClass()
 
37
    scenarios = [
 
38
        (name, {'merge_type': merger})
 
39
        for name, merger in _mod_merge.merge_type_registry.items()]
 
40
    return multiply_tests(standard_tests, scenarios, result)
 
41
 
 
42
 
 
43
class TestMergeImplementation(TestCaseWithTransport):
 
44
 
 
45
    def do_merge(self, target_tree, source_tree, **kwargs):
 
46
        merger = _mod_merge.Merger.from_revision_ids(
 
47
            target_tree, source_tree.last_revision(),
 
48
            other_branch=source_tree.branch)
 
49
        merger.merge_type = self.merge_type
 
50
        for name, value in kwargs.items():
 
51
            setattr(merger, name, value)
 
52
        merger.do_merge()
 
53
 
 
54
    def test_merge_specific_file(self):
 
55
        this_tree = self.make_branch_and_tree('this')
 
56
        this_tree.lock_write()
 
57
        self.addCleanup(this_tree.unlock)
 
58
        self.build_tree_contents([
 
59
            ('this/file1', b'a\nb\n'),
 
60
            ('this/file2', b'a\nb\n')
 
61
        ])
 
62
        this_tree.add(['file1', 'file2'])
 
63
        this_tree.commit('Added files')
 
64
        other_tree = this_tree.controldir.sprout('other').open_workingtree()
 
65
        self.build_tree_contents([
 
66
            ('other/file1', b'a\nb\nc\n'),
 
67
            ('other/file2', b'a\nb\nc\n')
 
68
        ])
 
69
        other_tree.commit('modified both')
 
70
        self.build_tree_contents([
 
71
            ('this/file1', b'd\na\nb\n'),
 
72
            ('this/file2', b'd\na\nb\n')
 
73
        ])
 
74
        this_tree.commit('modified both')
 
75
        self.do_merge(this_tree, other_tree, interesting_files=['file1'])
 
76
        self.assertFileEqual(b'd\na\nb\nc\n', 'this/file1')
 
77
        self.assertFileEqual(b'd\na\nb\n', 'this/file2')
 
78
 
 
79
    def test_merge_move_and_change(self):
 
80
        this_tree = self.make_branch_and_tree('this')
 
81
        this_tree.lock_write()
 
82
        self.addCleanup(this_tree.unlock)
 
83
        self.build_tree_contents([
 
84
            ('this/file1', b'line 1\nline 2\nline 3\nline 4\n'),
 
85
        ])
 
86
        this_tree.add('file1',)
 
87
        this_tree.commit('Added file')
 
88
        other_tree = this_tree.controldir.sprout('other').open_workingtree()
 
89
        self.build_tree_contents([
 
90
            ('other/file1', b'line 1\nline 2 to 2.1\nline 3\nline 4\n'),
 
91
        ])
 
92
        other_tree.commit('Changed 2 to 2.1')
 
93
        self.build_tree_contents([
 
94
            ('this/file1', b'line 1\nline 3\nline 2\nline 4\n'),
 
95
        ])
 
96
        this_tree.commit('Swapped 2 & 3')
 
97
        self.do_merge(this_tree, other_tree)
 
98
        if self.merge_type is _mod_merge.LCAMerger:
 
99
            self.expectFailure(
 
100
                "lca merge doesn't conflict for move and change",
 
101
                self.assertFileEqual,
 
102
                'line 1\n'
 
103
                '<<<<<<< TREE\n'
 
104
                'line 3\n'
 
105
                'line 2\n'
 
106
                '=======\n'
 
107
                'line 2 to 2.1\n'
 
108
                'line 3\n'
 
109
                '>>>>>>> MERGE-SOURCE\n'
 
110
                'line 4\n', 'this/file1')
 
111
        else:
 
112
            self.assertFileEqual(
 
113
                'line 1\n'
 
114
                '<<<<<<< TREE\n'
 
115
                'line 3\n'
 
116
                'line 2\n'
 
117
                '=======\n'
 
118
                'line 2 to 2.1\n'
 
119
                'line 3\n'
 
120
                '>>>>>>> MERGE-SOURCE\n'
 
121
                'line 4\n', 'this/file1')
 
122
 
 
123
    def test_modify_conflicts_with_delete(self):
 
124
        # If one side deletes a line, and the other modifies that line, then
 
125
        # the modification should be considered a conflict
 
126
        builder = self.make_branch_builder('test')
 
127
        builder.start_series()
 
128
        builder.build_snapshot(None,
 
129
                               [('add', ('', None, 'directory', None)),
 
130
                                ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),
 
131
                                ], revision_id=b'BASE-id')
 
132
        # Delete 'b\n'
 
133
        builder.build_snapshot([b'BASE-id'],
 
134
                               [('modify', ('foo', b'a\nc\nd\ne\n'))],
 
135
                               revision_id=b'OTHER-id')
 
136
        # Modify 'b\n', add 'X\n'
 
137
        builder.build_snapshot([b'BASE-id'],
 
138
                               [('modify', ('foo', b'a\nb2\nc\nd\nX\ne\n'))],
 
139
                               revision_id=b'THIS-id')
 
140
        builder.finish_series()
 
141
        branch = builder.get_branch()
 
142
        this_tree = branch.controldir.create_workingtree()
 
143
        this_tree.lock_write()
 
144
        self.addCleanup(this_tree.unlock)
 
145
        other_tree = this_tree.controldir.sprout(
 
146
            'other', b'OTHER-id').open_workingtree()
 
147
        self.do_merge(this_tree, other_tree)
 
148
        if self.merge_type is _mod_merge.LCAMerger:
 
149
            self.expectFailure("lca merge doesn't track deleted lines",
 
150
                               self.assertFileEqual,
 
151
                               'a\n'
 
152
                               '<<<<<<< TREE\n'
 
153
                               'b2\n'
 
154
                               '=======\n'
 
155
                               '>>>>>>> MERGE-SOURCE\n'
 
156
                               'c\n'
 
157
                               'd\n'
 
158
                               'X\n'
 
159
                               'e\n', 'test/foo')
 
160
        else:
 
161
            self.assertFileEqual(
 
162
                b'a\n'
 
163
                b'<<<<<<< TREE\n'
 
164
                b'b2\n'
 
165
                b'=======\n'
 
166
                b'>>>>>>> MERGE-SOURCE\n'
 
167
                b'c\n'
 
168
                b'd\n'
 
169
                b'X\n'
 
170
                b'e\n', 'test/foo')
 
171
 
 
172
    def get_limbodir_deletiondir(self, wt):
 
173
        transform = TreeTransform(wt)
 
174
        limbodir = transform._limbodir
 
175
        deletiondir = transform._deletiondir
 
176
        transform.finalize()
 
177
        return (limbodir, deletiondir)
 
178
 
 
179
    def test_merge_with_existing_limbo_empty(self):
 
180
        """Empty limbo dir is just cleaned up - see bug 427773"""
 
181
        wt = self.make_branch_and_tree('this')
 
182
        (limbodir, deletiondir) = self.get_limbodir_deletiondir(wt)
 
183
        os.mkdir(limbodir)
 
184
        self.do_merge(wt, wt)
 
185
 
 
186
    def test_merge_with_existing_limbo_non_empty(self):
 
187
        wt = self.make_branch_and_tree('this')
 
188
        (limbodir, deletiondir) = self.get_limbodir_deletiondir(wt)
 
189
        os.mkdir(limbodir)
 
190
        os.mkdir(os.path.join(limbodir, 'something'))
 
191
        self.assertRaises(errors.ExistingLimbo, self.do_merge, wt, wt)
 
192
        self.assertRaises(errors.LockError, wt.unlock)
 
193
 
 
194
    def test_merge_with_pending_deletion_empty(self):
 
195
        wt = self.make_branch_and_tree('this')
 
196
        (limbodir, deletiondir) = self.get_limbodir_deletiondir(wt)
 
197
        os.mkdir(deletiondir)
 
198
        self.do_merge(wt, wt)
 
199
 
 
200
    def test_merge_with_pending_deletion_non_empty(self):
 
201
        """Also see bug 427773"""
 
202
        wt = self.make_branch_and_tree('this')
 
203
        (limbodir, deletiondir) = self.get_limbodir_deletiondir(wt)
 
204
        os.mkdir(deletiondir)
 
205
        os.mkdir(os.path.join(deletiondir, 'something'))
 
206
        self.assertRaises(errors.ExistingPendingDeletion,
 
207
                          self.do_merge, wt, wt)
 
208
        self.assertRaises(errors.LockError, wt.unlock)
 
209
 
 
210
 
 
211
class TestHookMergeFileContent(TestCaseWithTransport):
 
212
    """Tests that the 'merge_file_content' hook is invoked."""
 
213
 
 
214
    def setUp(self):
 
215
        super(TestHookMergeFileContent, self).setUp()
 
216
        self.hook_log = []
 
217
 
 
218
    def install_hook_inactive(self):
 
219
        def inactive_factory(merger):
 
220
            # This hook is never active
 
221
            self.hook_log.append(('inactive',))
 
222
            return None
 
223
        _mod_merge.Merger.hooks.install_named_hook(
 
224
            'merge_file_content', inactive_factory, 'test hook (inactive)')
 
225
 
 
226
    def install_hook_noop(self):
 
227
        test = self
 
228
 
 
229
        class HookNA(_mod_merge.AbstractPerFileMerger):
 
230
            def merge_contents(self, merge_params):
 
231
                # This hook unconditionally does nothing.
 
232
                test.hook_log.append(('no-op',))
 
233
                return 'not_applicable', None
 
234
 
 
235
        def hook_na_factory(merger):
 
236
            return HookNA(merger)
 
237
        _mod_merge.Merger.hooks.install_named_hook(
 
238
            'merge_file_content', hook_na_factory, 'test hook (no-op)')
 
239
 
 
240
    def install_hook_success(self):
 
241
        test = self
 
242
 
 
243
        class HookSuccess(_mod_merge.AbstractPerFileMerger):
 
244
            def merge_contents(self, merge_params):
 
245
                test.hook_log.append(('success',))
 
246
                if merge_params.file_id == b'1':
 
247
                    return 'success', [b'text-merged-by-hook']
 
248
                return 'not_applicable', None
 
249
 
 
250
        def hook_success_factory(merger):
 
251
            return HookSuccess(merger)
 
252
        _mod_merge.Merger.hooks.install_named_hook(
 
253
            'merge_file_content', hook_success_factory, 'test hook (success)')
 
254
 
 
255
    def install_hook_conflict(self):
 
256
        test = self
 
257
 
 
258
        class HookConflict(_mod_merge.AbstractPerFileMerger):
 
259
            def merge_contents(self, merge_params):
 
260
                test.hook_log.append(('conflict',))
 
261
                if merge_params.file_id == b'1':
 
262
                    return ('conflicted',
 
263
                            [b'text-with-conflict-markers-from-hook'])
 
264
                return 'not_applicable', None
 
265
 
 
266
        def hook_conflict_factory(merger):
 
267
            return HookConflict(merger)
 
268
        _mod_merge.Merger.hooks.install_named_hook(
 
269
            'merge_file_content', hook_conflict_factory, 'test hook (delete)')
 
270
 
 
271
    def install_hook_delete(self):
 
272
        test = self
 
273
 
 
274
        class HookDelete(_mod_merge.AbstractPerFileMerger):
 
275
            def merge_contents(self, merge_params):
 
276
                test.hook_log.append(('delete',))
 
277
                if merge_params.file_id == b'1':
 
278
                    return 'delete', None
 
279
                return 'not_applicable', None
 
280
 
 
281
        def hook_delete_factory(merger):
 
282
            return HookDelete(merger)
 
283
        _mod_merge.Merger.hooks.install_named_hook(
 
284
            'merge_file_content', hook_delete_factory, 'test hook (delete)')
 
285
 
 
286
    def install_hook_log_lines(self):
 
287
        """Install a hook that saves the get_lines for the this, base and other
 
288
        versions of the file.
 
289
        """
 
290
        test = self
 
291
 
 
292
        class HookLogLines(_mod_merge.AbstractPerFileMerger):
 
293
            def merge_contents(self, merge_params):
 
294
                test.hook_log.append((
 
295
                    'log_lines',
 
296
                    merge_params.this_lines,
 
297
                    merge_params.other_lines,
 
298
                    merge_params.base_lines,
 
299
                    ))
 
300
                return 'not_applicable', None
 
301
 
 
302
        def hook_log_lines_factory(merger):
 
303
            return HookLogLines(merger)
 
304
        _mod_merge.Merger.hooks.install_named_hook(
 
305
            'merge_file_content', hook_log_lines_factory,
 
306
            'test hook (log_lines)')
 
307
 
 
308
    def make_merge_builder(self):
 
309
        builder = MergeBuilder(self.test_base_dir)
 
310
        self.addCleanup(builder.cleanup)
 
311
        return builder
 
312
 
 
313
    def create_file_needing_contents_merge(self, builder, file_id):
 
314
        builder.add_file(file_id, builder.tree_root, "name1", b"text1", True)
 
315
        builder.change_contents(file_id, other=b"text4", this=b"text3")
 
316
 
 
317
    def test_change_vs_change(self):
 
318
        """Hook is used for (changed, changed)"""
 
319
        self.install_hook_success()
 
320
        builder = self.make_merge_builder()
 
321
        builder.add_file(b"1", builder.tree_root, "name1", b"text1", True)
 
322
        builder.change_contents(b"1", other=b"text4", this=b"text3")
 
323
        conflicts = builder.merge(self.merge_type)
 
324
        self.assertEqual(conflicts, [])
 
325
        with builder.this.get_file('name1') as f:
 
326
            self.assertEqual(f.read(), b'text-merged-by-hook')
 
327
 
 
328
    def test_change_vs_deleted(self):
 
329
        """Hook is used for (changed, deleted)"""
 
330
        self.install_hook_success()
 
331
        builder = self.make_merge_builder()
 
332
        builder.add_file(b"1", builder.tree_root, "name1", b"text1", True)
 
333
        builder.change_contents(b"1", this=b"text2")
 
334
        builder.remove_file(b"1", other=True)
 
335
        conflicts = builder.merge(self.merge_type)
 
336
        self.assertEqual(conflicts, [])
 
337
        with builder.this.get_file('name1') as f:
 
338
            self.assertEqual(f.read(), b'text-merged-by-hook')
 
339
 
 
340
    def test_result_can_be_delete(self):
 
341
        """A hook's result can be the deletion of a file."""
 
342
        self.install_hook_delete()
 
343
        builder = self.make_merge_builder()
 
344
        self.create_file_needing_contents_merge(builder, b"1")
 
345
        conflicts = builder.merge(self.merge_type)
 
346
        self.assertEqual(conflicts, [])
 
347
        self.assertRaises(errors.NoSuchId, builder.this.id2path, b'1')
 
348
        self.assertEqual([], list(builder.this.list_files()))
 
349
 
 
350
    def test_result_can_be_conflict(self):
 
351
        """A hook's result can be a conflict."""
 
352
        self.install_hook_conflict()
 
353
        builder = self.make_merge_builder()
 
354
        self.create_file_needing_contents_merge(builder, b"1")
 
355
        conflicts = builder.merge(self.merge_type)
 
356
        self.assertEqual(conflicts, [TextConflict('name1', file_id=b'1')])
 
357
        # The hook still gets to set the file contents in this case, so that it
 
358
        # can insert custom conflict markers.
 
359
        with builder.this.get_file('name1') as f:
 
360
            self.assertEqual(f.read(), b'text-with-conflict-markers-from-hook')
 
361
 
 
362
    def test_can_access_this_other_and_base_versions(self):
 
363
        """The hook function can call params.merger.get_lines to access the
 
364
        THIS/OTHER/BASE versions of the file.
 
365
        """
 
366
        self.install_hook_log_lines()
 
367
        builder = self.make_merge_builder()
 
368
        builder.add_file(b"1", builder.tree_root, "name1", b"text1", True)
 
369
        builder.change_contents(b"1", this=b"text2", other=b"text3")
 
370
        conflicts = builder.merge(self.merge_type)
 
371
        self.assertEqual(
 
372
            [('log_lines', [b'text2'], [b'text3'], [b'text1'])], self.hook_log)
 
373
 
 
374
    def test_chain_when_not_active(self):
 
375
        """When a hook function returns None, merging still works."""
 
376
        self.install_hook_inactive()
 
377
        self.install_hook_success()
 
378
        builder = self.make_merge_builder()
 
379
        self.create_file_needing_contents_merge(builder, b"1")
 
380
        conflicts = builder.merge(self.merge_type)
 
381
        self.assertEqual(conflicts, [])
 
382
        with builder.this.get_file('name1') as f:
 
383
            self.assertEqual(f.read(), b'text-merged-by-hook')
 
384
        self.assertEqual([('inactive',), ('success',)], self.hook_log)
 
385
 
 
386
    def test_chain_when_not_applicable(self):
 
387
        """When a hook function returns not_applicable, the next function is
 
388
        tried (when one exists).
 
389
        """
 
390
        self.install_hook_noop()
 
391
        self.install_hook_success()
 
392
        builder = self.make_merge_builder()
 
393
        self.create_file_needing_contents_merge(builder, b"1")
 
394
        conflicts = builder.merge(self.merge_type)
 
395
        self.assertEqual(conflicts, [])
 
396
        with builder.this.get_file('name1') as f:
 
397
            self.assertEqual(f.read(), b'text-merged-by-hook')
 
398
        self.assertEqual([('no-op',), ('success',)], self.hook_log)
 
399
 
 
400
    def test_chain_stops_after_success(self):
 
401
        """When a hook function returns success, no later functions are tried.
 
402
        """
 
403
        self.install_hook_success()
 
404
        self.install_hook_noop()
 
405
        builder = self.make_merge_builder()
 
406
        self.create_file_needing_contents_merge(builder, b"1")
 
407
        conflicts = builder.merge(self.merge_type)
 
408
        self.assertEqual([('success',)], self.hook_log)
 
409
 
 
410
    def test_chain_stops_after_conflict(self):
 
411
        """When a hook function returns conflict, no later functions are tried.
 
412
        """
 
413
        self.install_hook_conflict()
 
414
        self.install_hook_noop()
 
415
        builder = self.make_merge_builder()
 
416
        self.create_file_needing_contents_merge(builder, b"1")
 
417
        conflicts = builder.merge(self.merge_type)
 
418
        self.assertEqual([('conflict',)], self.hook_log)
 
419
 
 
420
    def test_chain_stops_after_delete(self):
 
421
        """When a hook function returns delete, no later functions are tried.
 
422
        """
 
423
        self.install_hook_delete()
 
424
        self.install_hook_noop()
 
425
        builder = self.make_merge_builder()
 
426
        self.create_file_needing_contents_merge(builder, b"1")
 
427
        conflicts = builder.merge(self.merge_type)
 
428
        self.assertEqual([('delete',)], self.hook_log)