125
157
self.assertEqual(conflicts.ConflictList([]), tree.conflicts())
128
class TestPerConflict(tests.TestCase):
130
scenarios = scenarios.multiply_scenarios(vary_by_conflicts())
132
def test_stringification(self):
133
text = unicode(self.conflict)
134
self.assertContainsString(text, self.conflict.path)
135
self.assertContainsString(text.lower(), "conflict")
136
self.assertContainsString(repr(self.conflict),
137
self.conflict.__class__.__name__)
160
class TestConflictStanzas(tests.TestCase):
139
162
def test_stanza_roundtrip(self):
141
o = conflicts.Conflict.factory(**p.as_stanza().as_dict())
142
self.assertEqual(o, p)
144
self.assertIsInstance(o.path, unicode)
146
if o.file_id is not None:
147
self.assertIsInstance(o.file_id, str)
149
conflict_path = getattr(o, 'conflict_path', None)
150
if conflict_path is not None:
151
self.assertIsInstance(conflict_path, unicode)
153
conflict_file_id = getattr(o, 'conflict_file_id', None)
154
if conflict_file_id is not None:
155
self.assertIsInstance(conflict_file_id, str)
163
# write and read our example stanza.
164
stanza_iter = example_conflicts.to_stanzas()
165
processed = conflicts.ConflictList.from_stanzas(stanza_iter)
166
for o, p in zip(processed, example_conflicts):
167
self.assertEqual(o, p)
169
self.assertIsInstance(o.path, unicode)
171
if o.file_id is not None:
172
self.assertIsInstance(o.file_id, str)
174
conflict_path = getattr(o, 'conflict_path', None)
175
if conflict_path is not None:
176
self.assertIsInstance(conflict_path, unicode)
178
conflict_file_id = getattr(o, 'conflict_file_id', None)
179
if conflict_file_id is not None:
180
self.assertIsInstance(conflict_file_id, str)
157
182
def test_stanzification(self):
158
stanza = self.conflict.as_stanza()
159
if 'file_id' in stanza:
160
# In Stanza form, the file_id has to be unicode.
161
self.assertStartsWith(stanza['file_id'], u'\xeed')
162
self.assertStartsWith(stanza['path'], u'p\xe5th')
163
if 'conflict_path' in stanza:
164
self.assertStartsWith(stanza['conflict_path'], u'p\xe5th')
165
if 'conflict_file_id' in stanza:
166
self.assertStartsWith(stanza['conflict_file_id'], u'\xeed')
169
class TestConflictList(tests.TestCase):
171
def test_stanzas_roundtrip(self):
172
stanzas_iter = example_conflicts.to_stanzas()
173
processed = conflicts.ConflictList.from_stanzas(stanzas_iter)
174
self.assertEqual(example_conflicts, processed)
176
def test_stringification(self):
177
for text, o in zip(example_conflicts.to_strings(), example_conflicts):
178
self.assertEqual(text, unicode(o))
183
for stanza in example_conflicts.to_stanzas():
184
if 'file_id' in stanza:
185
# In Stanza form, the file_id has to be unicode.
186
self.assertStartsWith(stanza['file_id'], u'\xeed')
187
self.assertStartsWith(stanza['path'], u'p\xe5th')
188
if 'conflict_path' in stanza:
189
self.assertStartsWith(stanza['conflict_path'], u'p\xe5th')
190
if 'conflict_file_id' in stanza:
191
self.assertStartsWith(stanza['conflict_file_id'], u'\xeed')
181
194
# FIXME: The shell-like tests should be converted to real whitebox tests... or
182
195
# moved to a blackbox module -- vila 20100205
184
# FIXME: test missing for multiple conflicts
186
197
# FIXME: Tests missing for DuplicateID conflict type
187
198
class TestResolveConflicts(script.TestCaseWithTransportAndScript):
193
204
self.run_script(self.preamble)
196
def mirror_scenarios(base_scenarios):
197
"""Return a list of mirrored scenarios.
199
Each scenario in base_scenarios is duplicated switching the roles of 'this'
203
for common, (lname, ldict), (rname, rdict) in base_scenarios:
204
a = tests.multiply_scenarios([(lname, dict(_this=ldict))],
205
[(rname, dict(_other=rdict))])
206
b = tests.multiply_scenarios([(rname, dict(_this=rdict))],
207
[(lname, dict(_other=ldict))])
208
# Inject the common parameters in all scenarios
209
for name, d in a + b:
211
scenarios.extend(a + b)
215
# FIXME: Get rid of parametrized (in the class name) once we delete
216
# TestResolveConflicts -- vila 20100308
217
class TestParametrizedResolveConflicts(tests.TestCaseWithTransport):
218
"""This class provides a base to test single conflict resolution.
220
Since all conflict objects are created with specific semantics for their
221
attributes, each class should implement the necessary functions and
222
attributes described below.
224
Each class should define the scenarios that create the expected (single)
227
Each scenario describes:
228
* how to create 'base' tree (and revision)
229
* how to create 'left' tree (and revision, parent rev 'base')
230
* how to create 'right' tree (and revision, parent rev 'base')
231
* how to check that changes in 'base'->'left' have been taken
232
* how to check that changes in 'base'->'right' have been taken
234
From each base scenario, we generate two concrete scenarios where:
235
* this=left, other=right
236
* this=right, other=left
238
Then the test case verifies each concrete scenario by:
239
* creating a branch containing the 'base', 'this' and 'other' revisions
240
* creating a working tree for the 'this' revision
241
* performing the merge of 'other' into 'this'
242
* verifying the expected conflict was generated
243
* resolving with --take-this or --take-other, and running the corresponding
244
checks (for either 'base'->'this', or 'base'->'other')
246
:cvar _conflict_type: The expected class of the generated conflict.
248
:cvar _assert_conflict: A method receiving the working tree and the
249
conflict object and checking its attributes.
251
:cvar _base_actions: The branchbuilder actions to create the 'base'
254
:cvar _this: The dict related to 'base' -> 'this'. It contains at least:
255
* 'actions': The branchbuilder actions to create the 'this'
257
* 'check': how to check the changes after resolution with --take-this.
259
:cvar _other: The dict related to 'base' -> 'other'. It contains at least:
260
* 'actions': The branchbuilder actions to create the 'other'
262
* 'check': how to check the changes after resolution with --take-other.
265
# Set by daughter classes
266
_conflict_type = None
267
_assert_conflict = None
207
class TestResolveTextConflicts(TestResolveConflicts):
212
def content_conflict_scenarios():
213
return [('file,None', dict(_this_actions='modify_file',
214
_check_this='file_has_more_content',
215
_other_actions='delete_file',
216
_check_other='file_doesnt_exist',
218
('None,file', dict(_this_actions='delete_file',
219
_check_this='file_doesnt_exist',
220
_other_actions='modify_file',
221
_check_other='file_has_more_content',
226
class TestResolveContentConflicts(tests.TestCaseWithTransport):
269
228
# Set by load_tests
275
"""The scenario list for the conflict type defined by the class.
277
Each scenario is of the form:
278
(common, (left_name, left_dict), (right_name, right_dict))
282
* left_name and right_name are the scenario names that will be combined
284
* left_dict and right_dict are the attributes specific to each half of
285
the scenario. They should include at least 'actions' and 'check' and
286
will be available as '_this' and '_other' test instance attributes.
288
Daughters classes are free to add their specific attributes as they see
289
fit in any of the three dicts.
291
This is a class method so that load_tests can find it.
293
'_base_actions' in the common dict, 'actions' and 'check' in the left
294
and right dicts use names that map to methods in the test classes. Some
295
prefixes are added to these names to get the correspong methods (see
296
_get_actions() and _get_check()). The motivation here is to avoid
297
collisions in the class namespace.
301
super(TestParametrizedResolveConflicts, self).setUp()
233
super(TestResolveContentConflicts, self).setUp()
302
234
builder = self.make_branch_builder('trunk')
303
235
builder.start_series()
305
236
# Create an empty trunk
306
237
builder.build_snapshot('start', None, [
307
238
('add', ('', 'root-id', 'directory', ''))])
308
239
# Add a minimal base content
309
base_actions = self._get_actions(self._base_actions)()
310
builder.build_snapshot('base', ['start'], base_actions)
240
builder.build_snapshot('base', ['start'], [
241
('add', ('file', 'file-id', 'file', 'trunk content\n'))])
311
242
# Modify the base content in branch
312
actions_other = self._get_actions(self._other['actions'])()
313
builder.build_snapshot('other', ['base'], actions_other)
243
other_actions = self._get_actions(self._other_actions)
244
builder.build_snapshot('other', ['base'], other_actions())
314
245
# Modify the base content in trunk
315
actions_this = self._get_actions(self._this['actions'])()
316
builder.build_snapshot('this', ['base'], actions_this)
317
# builder.get_branch() tip is now 'this'
246
this_actions = self._get_actions(self._this_actions)
247
builder.build_snapshot('this', ['base'], this_actions())
319
248
builder.finish_series()
320
249
self.builder = builder
325
254
def _get_check(self, name):
326
255
return getattr(self, 'check_%s' % name)
257
def do_modify_file(self):
258
return [('modify', ('file-id', 'trunk content\nmore content\n'))]
260
def check_file_has_more_content(self):
261
self.assertFileEqual('trunk content\nmore content\n', 'branch/file')
263
def do_delete_file(self):
264
return [('unversion', 'file-id')]
266
def check_file_doesnt_exist(self):
267
self.failIfExists('branch/file')
328
269
def _merge_other_into_this(self):
329
270
b = self.builder.get_branch()
330
271
wt = b.bzrdir.sprout('branch').open_workingtree()
331
272
wt.merge_from_branch(b, 'other')
334
def assertConflict(self, wt):
275
def assertConflict(self, wt, ctype, **kwargs):
335
276
confs = wt.conflicts()
336
277
self.assertLength(1, confs)
338
self.assertIsInstance(c, self._conflict_type)
339
self._assert_conflict(wt, c)
341
def _get_resolve_path_arg(self, wt, action):
342
raise NotImplementedError(self._get_resolve_path_arg)
344
def check_resolved(self, wt, action):
345
path = self._get_resolve_path_arg(wt, action)
346
conflicts.resolve(wt, [path], action=action)
279
self.assertIsInstance(c, ctype)
280
sentinel = object() # An impossible value
281
for k, v in kwargs.iteritems():
282
self.assertEqual(v, getattr(c, k, sentinel))
284
def check_resolved(self, wt, item, action):
285
conflicts.resolve(wt, [item], action=action)
347
286
# Check that we don't have any conflicts nor unknown left
348
287
self.assertLength(0, wt.conflicts())
349
288
self.assertLength(0, list(wt.unknowns()))
351
290
def test_resolve_taking_this(self):
352
291
wt = self._merge_other_into_this()
353
self.assertConflict(wt)
354
self.check_resolved(wt, 'take_this')
355
check_this = self._get_check(self._this['check'])
292
self.assertConflict(wt, conflicts.ContentsConflict,
293
path='file', file_id='file-id',)
294
self.check_resolved(wt, 'file', 'take_this')
295
check_this = self._get_check(self._check_this)
358
298
def test_resolve_taking_other(self):
359
299
wt = self._merge_other_into_this()
360
self.assertConflict(wt)
361
self.check_resolved(wt, 'take_other')
362
check_other = self._get_check(self._other['check'])
300
self.assertConflict(wt, conflicts.ContentsConflict,
301
path='file', file_id='file-id',)
302
self.check_resolved(wt, 'file', 'take_other')
303
check_other = self._get_check(self._check_other)
366
class TestResolveTextConflicts(TestParametrizedResolveConflicts):
368
_conflict_type = conflicts.TextConflict
370
# Set by the scenarios
371
# path and file-id for the file involved in the conflict
375
scenarios = mirror_scenarios(
377
# File modified on both sides
378
(dict(_base_actions='create_file',
379
_path='file', _file_id='file-id'),
381
dict(actions='modify_file_A', check='file_has_content_A')),
383
dict(actions='modify_file_B', check='file_has_content_B')),),
384
# File modified on both sides in dir
385
(dict(_base_actions='create_file_in_dir',
386
_path='dir/file', _file_id='file-id'),
387
('filed_modified_A_in_dir',
388
dict(actions='modify_file_A',
389
check='file_in_dir_has_content_A')),
391
dict(actions='modify_file_B',
392
check='file_in_dir_has_content_B')),),
395
def do_create_file(self, path='file'):
396
return [('add', (path, 'file-id', 'file', 'trunk content\n'))]
398
def do_modify_file_A(self):
399
return [('modify', ('file-id', 'trunk content\nfeature A\n'))]
401
def do_modify_file_B(self):
402
return [('modify', ('file-id', 'trunk content\nfeature B\n'))]
404
def check_file_has_content_A(self, path='file'):
405
self.assertFileEqual('trunk content\nfeature A\n',
406
osutils.pathjoin('branch', path))
408
def check_file_has_content_B(self, path='file'):
409
self.assertFileEqual('trunk content\nfeature B\n',
410
osutils.pathjoin('branch', path))
412
def do_create_file_in_dir(self):
413
return [('add', ('dir', 'dir-id', 'directory', '')),
414
] + self.do_create_file('dir/file')
416
def check_file_in_dir_has_content_A(self):
417
self.check_file_has_content_A('dir/file')
419
def check_file_in_dir_has_content_B(self):
420
self.check_file_has_content_B('dir/file')
422
def _get_resolve_path_arg(self, wt, action):
425
def assertTextConflict(self, wt, c):
426
self.assertEqual(self._file_id, c.file_id)
427
self.assertEqual(self._path, c.path)
428
_assert_conflict = assertTextConflict
431
class TestResolveContentsConflict(TestParametrizedResolveConflicts):
433
_conflict_type = conflicts.ContentsConflict
435
# Set by the scenarios
436
# path and file-id for the file involved in the conflict
440
scenarios = mirror_scenarios(
442
# File modified/deleted
443
(dict(_base_actions='create_file',
444
_path='file', _file_id='file-id'),
446
dict(actions='modify_file', check='file_has_more_content')),
448
dict(actions='delete_file', check='file_doesnt_exist')),),
449
# File renamed-modified/deleted
450
(dict(_base_actions='create_file',
451
_path='new-file', _file_id='file-id'),
452
('file_renamed_and_modified',
453
dict(actions='modify_and_rename_file',
454
check='file_renamed_and_more_content')),
456
dict(actions='delete_file', check='file_doesnt_exist')),),
457
# File modified/deleted in dir
458
(dict(_base_actions='create_file_in_dir',
459
_path='dir/file', _file_id='file-id'),
460
('file_modified_in_dir',
461
dict(actions='modify_file_in_dir',
462
check='file_in_dir_has_more_content')),
463
('file_deleted_in_dir',
464
dict(actions='delete_file',
465
check='file_in_dir_doesnt_exist')),),
468
def do_create_file(self):
469
return [('add', ('file', 'file-id', 'file', 'trunk content\n'))]
471
def do_modify_file(self):
472
return [('modify', ('file-id', 'trunk content\nmore content\n'))]
474
def do_modify_and_rename_file(self):
475
return [('modify', ('file-id', 'trunk content\nmore content\n')),
476
('rename', ('file', 'new-file'))]
478
def check_file_has_more_content(self):
479
self.assertFileEqual('trunk content\nmore content\n', 'branch/file')
481
def check_file_renamed_and_more_content(self):
482
self.assertFileEqual('trunk content\nmore content\n', 'branch/new-file')
484
def do_delete_file(self):
485
return [('unversion', 'file-id')]
487
def check_file_doesnt_exist(self):
488
self.assertPathDoesNotExist('branch/file')
490
def do_create_file_in_dir(self):
491
return [('add', ('dir', 'dir-id', 'directory', '')),
492
('add', ('dir/file', 'file-id', 'file', 'trunk content\n'))]
494
def do_modify_file_in_dir(self):
495
return [('modify', ('file-id', 'trunk content\nmore content\n'))]
497
def check_file_in_dir_has_more_content(self):
498
self.assertFileEqual('trunk content\nmore content\n', 'branch/dir/file')
500
def check_file_in_dir_doesnt_exist(self):
501
self.assertPathDoesNotExist('branch/dir/file')
503
def _get_resolve_path_arg(self, wt, action):
506
def assertContentsConflict(self, wt, c):
507
self.assertEqual(self._file_id, c.file_id)
508
self.assertEqual(self._path, c.path)
509
_assert_conflict = assertContentsConflict
512
class TestResolvePathConflict(TestParametrizedResolveConflicts):
514
_conflict_type = conflicts.PathConflict
516
def do_nothing(self):
519
# Each side dict additionally defines:
520
# - path path involved (can be '<deleted>')
522
scenarios = mirror_scenarios(
524
# File renamed/deleted
525
(dict(_base_actions='create_file'),
527
dict(actions='rename_file', check='file_renamed',
528
path='new-file', file_id='file-id')),
530
dict(actions='delete_file', check='file_doesnt_exist',
531
# PathConflicts deletion handling requires a special
533
path='<deleted>', file_id='file-id')),),
534
# File renamed/deleted in dir
535
(dict(_base_actions='create_file_in_dir'),
536
('file_renamed_in_dir',
537
dict(actions='rename_file_in_dir', check='file_in_dir_renamed',
538
path='dir/new-file', file_id='file-id')),
540
dict(actions='delete_file', check='file_in_dir_doesnt_exist',
541
# PathConflicts deletion handling requires a special
543
path='<deleted>', file_id='file-id')),),
544
# File renamed/renamed differently
545
(dict(_base_actions='create_file'),
547
dict(actions='rename_file', check='file_renamed',
548
path='new-file', file_id='file-id')),
550
dict(actions='rename_file2', check='file_renamed2',
551
path='new-file2', file_id='file-id')),),
552
# Dir renamed/deleted
553
(dict(_base_actions='create_dir'),
555
dict(actions='rename_dir', check='dir_renamed',
556
path='new-dir', file_id='dir-id')),
558
dict(actions='delete_dir', check='dir_doesnt_exist',
559
# PathConflicts deletion handling requires a special
561
path='<deleted>', file_id='dir-id')),),
562
# Dir renamed/renamed differently
563
(dict(_base_actions='create_dir'),
565
dict(actions='rename_dir', check='dir_renamed',
566
path='new-dir', file_id='dir-id')),
568
dict(actions='rename_dir2', check='dir_renamed2',
569
path='new-dir2', file_id='dir-id')),),
572
def do_create_file(self):
573
return [('add', ('file', 'file-id', 'file', 'trunk content\n'))]
575
def do_create_dir(self):
576
return [('add', ('dir', 'dir-id', 'directory', ''))]
578
def do_rename_file(self):
579
return [('rename', ('file', 'new-file'))]
581
def check_file_renamed(self):
582
self.assertPathDoesNotExist('branch/file')
583
self.assertPathExists('branch/new-file')
585
def do_rename_file2(self):
586
return [('rename', ('file', 'new-file2'))]
588
def check_file_renamed2(self):
589
self.assertPathDoesNotExist('branch/file')
590
self.assertPathExists('branch/new-file2')
592
def do_rename_dir(self):
593
return [('rename', ('dir', 'new-dir'))]
595
def check_dir_renamed(self):
596
self.assertPathDoesNotExist('branch/dir')
597
self.assertPathExists('branch/new-dir')
599
def do_rename_dir2(self):
600
return [('rename', ('dir', 'new-dir2'))]
602
def check_dir_renamed2(self):
603
self.assertPathDoesNotExist('branch/dir')
604
self.assertPathExists('branch/new-dir2')
606
def do_delete_file(self):
607
return [('unversion', 'file-id')]
609
def check_file_doesnt_exist(self):
610
self.assertPathDoesNotExist('branch/file')
612
def do_delete_dir(self):
613
return [('unversion', 'dir-id')]
615
def check_dir_doesnt_exist(self):
616
self.assertPathDoesNotExist('branch/dir')
618
def do_create_file_in_dir(self):
619
return [('add', ('dir', 'dir-id', 'directory', '')),
620
('add', ('dir/file', 'file-id', 'file', 'trunk content\n'))]
622
def do_rename_file_in_dir(self):
623
return [('rename', ('dir/file', 'dir/new-file'))]
625
def check_file_in_dir_renamed(self):
626
self.assertPathDoesNotExist('branch/dir/file')
627
self.assertPathExists('branch/dir/new-file')
629
def check_file_in_dir_doesnt_exist(self):
630
self.assertPathDoesNotExist('branch/dir/file')
632
def _get_resolve_path_arg(self, wt, action):
633
tpath = self._this['path']
634
opath = self._other['path']
635
if tpath == '<deleted>':
641
def assertPathConflict(self, wt, c):
642
tpath = self._this['path']
643
tfile_id = self._this['file_id']
644
opath = self._other['path']
645
ofile_id = self._other['file_id']
646
self.assertEqual(tfile_id, ofile_id) # Sanity check
647
self.assertEqual(tfile_id, c.file_id)
648
self.assertEqual(tpath, c.path)
649
self.assertEqual(opath, c.conflict_path)
650
_assert_conflict = assertPathConflict
653
class TestResolvePathConflictBefore531967(TestResolvePathConflict):
654
"""Same as TestResolvePathConflict but a specific conflict object.
657
def assertPathConflict(self, c):
658
# We create a conflict object as it was created before the fix and
659
# inject it into the working tree, the test will exercise the
660
# compatibility code.
661
old_c = conflicts.PathConflict('<deleted>', self._item_path,
663
wt.set_conflicts(conflicts.ConflictList([old_c]))
666
class TestResolveDuplicateEntry(TestParametrizedResolveConflicts):
668
_conflict_type = conflicts.DuplicateEntry
670
scenarios = mirror_scenarios(
672
# File created with different file-ids
673
(dict(_base_actions='nothing'),
675
dict(actions='create_file_a', check='file_content_a',
676
path='file', file_id='file-a-id')),
678
dict(actions='create_file_b', check='file_content_b',
679
path='file', file_id='file-b-id')),),
682
def do_nothing(self):
685
def do_create_file_a(self):
686
return [('add', ('file', 'file-a-id', 'file', 'file a content\n'))]
688
def check_file_content_a(self):
689
self.assertFileEqual('file a content\n', 'branch/file')
691
def do_create_file_b(self):
692
return [('add', ('file', 'file-b-id', 'file', 'file b content\n'))]
694
def check_file_content_b(self):
695
self.assertFileEqual('file b content\n', 'branch/file')
697
def _get_resolve_path_arg(self, wt, action):
698
return self._this['path']
700
def assertDuplicateEntry(self, wt, c):
701
tpath = self._this['path']
702
tfile_id = self._this['file_id']
703
opath = self._other['path']
704
ofile_id = self._other['file_id']
705
self.assertEqual(tpath, opath) # Sanity check
706
self.assertEqual(tfile_id, c.file_id)
707
self.assertEqual(tpath + '.moved', c.path)
708
self.assertEqual(tpath, c.conflict_path)
709
_assert_conflict = assertDuplicateEntry
307
class TestResolveDuplicateEntry(TestResolveConflicts):
312
$ echo 'trunk content' >file
314
$ bzr commit -m 'Create trunk'
316
$ echo 'trunk content too' >file2
318
$ bzr commit -m 'Add file2 in trunk'
320
$ bzr branch . -r 1 ../branch
322
$ echo 'branch content' >file2
324
$ bzr commit -m 'Add file2 in branch'
328
2>R file2 => file2.moved
329
2>Conflict adding file file2. Moved existing file to file2.moved.
330
2>1 conflicts encountered.
333
def test_keep_this(self):
335
$ bzr rm file2 --force
336
$ bzr mv file2.moved file2
338
$ bzr commit --strict -m 'No more conflicts nor unknown files'
341
def test_keep_other(self):
342
self.failIfExists('branch/file2.moved')
344
$ bzr rm file2.moved --force
346
$ bzr commit --strict -m 'No more conflicts nor unknown files'
348
self.failIfExists('branch/file2.moved')
350
def test_resolve_taking_this(self):
352
$ bzr resolve --take-this file2
353
$ bzr commit --strict -m 'No more conflicts nor unknown files'
356
def test_resolve_taking_other(self):
358
$ bzr resolve --take-other file2
359
$ bzr commit --strict -m 'No more conflicts nor unknown files'
712
363
class TestResolveUnversionedParent(TestResolveConflicts):
846
496
def test_keep_them_all(self):
847
497
self.run_script("""
848
498
$ bzr resolve dir
849
2>2 conflict(s) resolved, 0 remaining
850
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
499
$ bzr commit --strict -m 'No more conflicts nor unknown files'
853
502
def test_adopt_child(self):
854
503
self.run_script("""
855
$ bzr mv -q dir/file2 file2
856
$ bzr rm -q dir --force
504
$ bzr mv dir/file2 file2
857
506
$ bzr resolve dir
858
2>2 conflict(s) resolved, 0 remaining
859
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
507
$ bzr commit --strict -m 'No more conflicts nor unknown files'
862
510
def test_kill_them_all(self):
863
511
self.run_script("""
864
$ bzr rm -q dir --force
865
513
$ bzr resolve dir
866
2>2 conflict(s) resolved, 0 remaining
867
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
514
$ bzr commit --strict -m 'No more conflicts nor unknown files'
870
517
def test_resolve_taking_this(self):
871
518
self.run_script("""
872
519
$ bzr resolve --take-this dir
873
2>2 conflict(s) resolved, 0 remaining
874
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
520
$ bzr commit --strict -m 'No more conflicts nor unknown files'
877
523
def test_resolve_taking_other(self):
878
524
self.run_script("""
879
525
$ bzr resolve --take-other dir
882
2>2 conflict(s) resolved, 0 remaining
883
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
887
class TestResolveParentLoop(TestParametrizedResolveConflicts):
889
_conflict_type = conflicts.ParentLoop
894
# Each side dict additionally defines:
895
# - dir_id: the directory being moved
896
# - target_id: The target directory
897
# - xfail: whether the test is expected to fail if the action is
898
# involved as 'other'
899
scenarios = mirror_scenarios(
901
# Dirs moved into each other
902
(dict(_base_actions='create_dir1_dir2'),
904
dict(actions='move_dir1_into_dir2', check='dir1_moved',
905
dir_id='dir1-id', target_id='dir2-id', xfail=False)),
907
dict(actions='move_dir2_into_dir1', check='dir2_moved',
908
dir_id='dir2-id', target_id='dir1-id', xfail=False))),
909
# Subdirs moved into each other
910
(dict(_base_actions='create_dir1_4'),
912
dict(actions='move_dir1_into_dir4', check='dir1_2_moved',
913
dir_id='dir1-id', target_id='dir4-id', xfail=True)),
915
dict(actions='move_dir3_into_dir2', check='dir3_4_moved',
916
dir_id='dir3-id', target_id='dir2-id', xfail=True))),
919
def do_create_dir1_dir2(self):
920
return [('add', ('dir1', 'dir1-id', 'directory', '')),
921
('add', ('dir2', 'dir2-id', 'directory', '')),]
923
def do_move_dir1_into_dir2(self):
924
return [('rename', ('dir1', 'dir2/dir1'))]
926
def check_dir1_moved(self):
927
self.assertPathDoesNotExist('branch/dir1')
928
self.assertPathExists('branch/dir2/dir1')
930
def do_move_dir2_into_dir1(self):
931
return [('rename', ('dir2', 'dir1/dir2'))]
933
def check_dir2_moved(self):
934
self.assertPathDoesNotExist('branch/dir2')
935
self.assertPathExists('branch/dir1/dir2')
937
def do_create_dir1_4(self):
938
return [('add', ('dir1', 'dir1-id', 'directory', '')),
939
('add', ('dir1/dir2', 'dir2-id', 'directory', '')),
940
('add', ('dir3', 'dir3-id', 'directory', '')),
941
('add', ('dir3/dir4', 'dir4-id', 'directory', '')),]
943
def do_move_dir1_into_dir4(self):
944
return [('rename', ('dir1', 'dir3/dir4/dir1'))]
946
def check_dir1_2_moved(self):
947
self.assertPathDoesNotExist('branch/dir1')
948
self.assertPathExists('branch/dir3/dir4/dir1')
949
self.assertPathExists('branch/dir3/dir4/dir1/dir2')
951
def do_move_dir3_into_dir2(self):
952
return [('rename', ('dir3', 'dir1/dir2/dir3'))]
954
def check_dir3_4_moved(self):
955
self.assertPathDoesNotExist('branch/dir3')
956
self.assertPathExists('branch/dir1/dir2/dir3')
957
self.assertPathExists('branch/dir1/dir2/dir3/dir4')
959
def _get_resolve_path_arg(self, wt, action):
960
# ParentLoop says: moving <conflict_path> into <path>. Cancelled move.
961
# But since <path> doesn't exist in the working tree, we need to use
962
# <conflict_path> instead, and that, in turn, is given by dir_id. Pfew.
963
return wt.id2path(self._other['dir_id'])
965
def assertParentLoop(self, wt, c):
966
self.assertEqual(self._other['dir_id'], c.file_id)
967
self.assertEqual(self._other['target_id'], c.conflict_file_id)
968
# The conflict paths are irrelevant (they are deterministic but not
969
# worth checking since they don't provide the needed information
971
if self._other['xfail']:
972
# It's a bit hackish to raise from here relying on being called for
973
# both tests but this avoid overriding test_resolve_taking_other
974
raise tests.KnownFailure(
975
"ParentLoop doesn't carry enough info to resolve --take-other")
976
_assert_conflict = assertParentLoop
526
$ bzr commit --strict -m 'No more conflicts nor unknown files'
530
class TestResolvePathConflict(TestResolveConflicts):
537
$ bzr commit -m 'Create trunk'
539
$ bzr mv file file-in-trunk
540
$ bzr commit -m 'Renamed to file-in-trunk'
542
$ bzr branch . -r 1 ../branch
544
$ bzr mv file file-in-branch
545
$ bzr commit -m 'Renamed to file-in-branch'
548
2>R file-in-branch => file-in-trunk
549
2>Path conflict: file-in-branch / file-in-trunk
550
2>1 conflicts encountered.
553
def test_keep_source(self):
555
$ bzr resolve file-in-trunk
556
$ bzr commit --strict -m 'No more conflicts nor unknown files'
559
def test_keep_target(self):
561
$ bzr mv file-in-trunk file-in-branch
562
$ bzr resolve file-in-branch
563
$ bzr commit --strict -m 'No more conflicts nor unknown files'
566
def test_resolve_taking_this(self):
568
$ bzr resolve --take-this file-in-branch
569
$ bzr commit --strict -m 'No more conflicts nor unknown files'
572
def test_resolve_taking_other(self):
574
$ bzr resolve --take-other file-in-branch
575
$ bzr commit --strict -m 'No more conflicts nor unknown files'
579
class TestResolveParentLoop(TestResolveConflicts):
586
$ bzr commit -m 'Create trunk'
589
$ bzr commit -m 'Moved dir2 into dir1'
591
$ bzr branch . -r 1 ../branch
594
$ bzr commit -m 'Moved dir1 into dir2'
597
2>Conflict moving dir2/dir1 into dir2. Cancelled move.
598
2>1 conflicts encountered.
601
def test_take_this(self):
604
$ bzr commit --strict -m 'No more conflicts nor unknown files'
607
def test_take_other(self):
609
$ bzr mv dir2/dir1 dir1
612
$ bzr commit --strict -m 'No more conflicts nor unknown files'
615
def test_resolve_taking_this(self):
617
$ bzr resolve --take-this dir2
618
$ bzr commit --strict -m 'No more conflicts nor unknown files'
620
self.failUnlessExists('dir2')
622
def test_resolve_taking_other(self):
624
$ bzr resolve --take-other dir2
625
$ bzr commit --strict -m 'No more conflicts nor unknown files'
627
self.failUnlessExists('dir1')
979
630
class TestResolveNonDirectoryParent(TestResolveConflicts):
987
$ bzr commit -m 'Create trunk' -q
636
$ bzr commit -m 'Create trunk'
988
637
$ echo "Boing" >foo/bar
990
$ bzr commit -q -m 'Add foo/bar'
991
$ bzr branch -q . -r 1 ../branch
639
$ bzr commit -m 'Add foo/bar'
641
$ bzr branch . -r 1 ../branch
994
644
$ echo "Boo!" >foo
995
$ bzr commit -q -m 'foo is now a file'
645
$ bzr commit -m 'foo is now a file'
996
647
$ bzr merge ../trunk
998
649
2>RK foo => foo.new/
added
removed
bzrlib/tests/test_conflicts.py
