/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_workingtree/test_transform.py

Split out bzr-specific Conflicts code.

Merged from https://code.launchpad.net/~jelmer/brz/conflict-refactor/+merge/388964

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/per_workingtree/test_transform.py
28
28
    transform,
29
29
    urlutils,
30
30
    )
31
 
from ...conflicts import (
 
31
from ...bzr.conflicts import (
32
32
    DeletingParent,
33
33
    DuplicateEntry,
34
34
    DuplicateID,
61
61
    )
62
62
from ...transform import (
63
63
    create_from_tree,
64
 
    cook_conflicts,
65
64
    FinalPaths,
66
65
    resolve_conflicts,
67
66
    resolve_checkout,
386
385
        transform.new_file('toto', dorothy, [b'toto-contents'], b'toto-id',
387
386
                           False)
388
387
 
389
 
        self.assertEqual(len(transform.find_conflicts()), 0)
 
388
        self.assertEqual(len(transform.find_raw_conflicts()), 0)
390
389
        transform.apply()
391
 
        self.assertRaises(ReusingTransform, transform.find_conflicts)
 
390
        self.assertRaises(ReusingTransform, transform.find_raw_conflicts)
392
391
        with open(self.wt.abspath('name'), 'r') as f:
393
392
            self.assertEqual('contents', f.read())
394
393
        self.assertEqual(self.wt.path2id('name'), b'my_pretties')
421
420
        transform, root = self.transform()
422
421
        trans_id = transform.new_file('name', root, [b'contents'],
423
422
                                      b'my_pretties')
424
 
        self.assertEqual(len(transform.find_conflicts()), 0)
 
423
        self.assertEqual(len(transform.find_raw_conflicts()), 0)
425
424
        trans_id2 = transform.new_file('name', root, [b'Crontents'], b'toto')
426
 
        self.assertEqual(transform.find_conflicts(),
 
425
        self.assertEqual(transform.find_raw_conflicts(),
427
426
                         [('duplicate', trans_id, trans_id2, 'name')])
428
427
        self.assertRaises(MalformedTransform, transform.apply)
429
428
        transform.adjust_path('name', trans_id, trans_id2)
430
 
        self.assertEqual(transform.find_conflicts(),
 
429
        self.assertEqual(transform.find_raw_conflicts(),
431
430
                         [('non-directory parent', trans_id)])
432
431
        tinman_id = transform.trans_id_tree_path('tinman')
433
432
        transform.adjust_path('name', tinman_id, trans_id2)
434
 
        self.assertEqual(transform.find_conflicts(),
 
433
        self.assertEqual(transform.find_raw_conflicts(),
435
434
                         [('unversioned parent', tinman_id),
436
435
                          ('missing parent', tinman_id)])
437
436
        lion_id = transform.create_path('lion', root)
438
 
        self.assertEqual(transform.find_conflicts(),
 
437
        self.assertEqual(transform.find_raw_conflicts(),
439
438
                         [('unversioned parent', tinman_id),
440
439
                          ('missing parent', tinman_id)])
441
440
        transform.adjust_path('name', lion_id, trans_id2)
442
 
        self.assertEqual(transform.find_conflicts(),
 
441
        self.assertEqual(transform.find_raw_conflicts(),
443
442
                         [('unversioned parent', lion_id),
444
443
                          ('missing parent', lion_id)])
445
444
        transform.version_file(lion_id, file_id=b"Courage")
446
 
        self.assertEqual(transform.find_conflicts(),
 
445
        self.assertEqual(transform.find_raw_conflicts(),
447
446
                         [('missing parent', lion_id),
448
447
                          ('versioning no contents', lion_id)])
449
448
        transform.adjust_path('name2', root, trans_id2)
450
 
        self.assertEqual(transform.find_conflicts(),
 
449
        self.assertEqual(transform.find_raw_conflicts(),
451
450
                         [('versioning no contents', lion_id)])
452
451
        transform.create_file([b'Contents, okay?'], lion_id)
453
452
        transform.adjust_path('name2', trans_id2, trans_id2)
454
 
        self.assertEqual(transform.find_conflicts(),
 
453
        self.assertEqual(transform.find_raw_conflicts(),
455
454
                         [('parent loop', trans_id2),
456
455
                          ('non-directory parent', trans_id2)])
457
456
        transform.adjust_path('name2', root, trans_id2)
458
457
        oz_id = transform.new_directory('oz', root)
459
458
        transform.set_executability(True, oz_id)
460
 
        self.assertEqual(transform.find_conflicts(),
 
459
        self.assertEqual(transform.find_raw_conflicts(),
461
460
                         [('unversioned executability', oz_id)])
462
461
        transform.version_file(oz_id, file_id=b'oz-id')
463
 
        self.assertEqual(transform.find_conflicts(),
 
462
        self.assertEqual(transform.find_raw_conflicts(),
464
463
                         [('non-file executability', oz_id)])
465
464
        transform.set_executability(None, oz_id)
466
465
        tip_id = transform.new_file('tip', oz_id, [b'ozma'], b'tip-id')
471
470
        transform2, root = self.transform()
472
471
        oz_id = transform2.trans_id_tree_path('oz')
473
472
        newtip = transform2.new_file('tip', oz_id, [b'other'], b'tip-id')
474
 
        result = transform2.find_conflicts()
 
473
        result = transform2.find_raw_conflicts()
475
474
        fp = FinalPaths(transform2)
476
475
        self.assertTrue('oz/tip' in transform2._tree_path_ids)
477
476
        self.assertEqual(fp.get_path(newtip), pathjoin('oz', 'tip'))
485
484
        self.addCleanup(transform3.finalize)
486
485
        oz_id = transform3.trans_id_tree_path('oz')
487
486
        transform3.delete_contents(oz_id)
488
 
        self.assertEqual(transform3.find_conflicts(),
 
487
        self.assertEqual(transform3.find_raw_conflicts(),
489
488
                         [('missing parent', oz_id)])
490
489
        root_id = transform3.root
491
490
        tip_id = transform3.trans_id_tree_path('oz/tip')
502
501
        self.addCleanup(transform.finalize)
503
502
        transform.new_file('file', transform.root, [b'content'])
504
503
        transform.new_file('FiLe', transform.root, [b'content'])
505
 
        result = transform.find_conflicts()
 
504
        result = transform.find_raw_conflicts()
506
505
        self.assertEqual([], result)
507
506
        transform.finalize()
508
507
        # Force the tree to report that it is case insensitive, for conflict
512
511
        self.addCleanup(transform.finalize)
513
512
        transform.new_file('file', transform.root, [b'content'])
514
513
        transform.new_file('FiLe', transform.root, [b'content'])
515
 
        result = transform.find_conflicts()
 
514
        result = transform.find_raw_conflicts()
516
515
        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
517
516
 
518
517
    def test_conflict_on_case_insensitive_existing(self):
525
524
        transform = tree.transform()
526
525
        self.addCleanup(transform.finalize)
527
526
        transform.new_file('file', transform.root, [b'content'])
528
 
        result = transform.find_conflicts()
 
527
        result = transform.find_raw_conflicts()
529
528
        self.assertEqual([], result)
530
529
        transform.finalize()
531
530
        # Force the tree to report that it is case insensitive, for conflict
534
533
        transform = tree.transform()
535
534
        self.addCleanup(transform.finalize)
536
535
        transform.new_file('file', transform.root, [b'content'])
537
 
        result = transform.find_conflicts()
 
536
        result = transform.find_raw_conflicts()
538
537
        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
539
538
 
540
539
    def test_resolve_case_insensitive_conflict(self):
630
629
        self.addCleanup(unversion.finalize)
631
630
        parent = unversion.trans_id_tree_path('parent')
632
631
        unversion.unversion_file(parent)
633
 
        self.assertEqual(unversion.find_conflicts(),
 
632
        self.assertEqual(unversion.find_raw_conflicts(),
634
633
                         [('unversioned parent', parent_id)])
635
634
        file_id = unversion.trans_id_tree_path('parent/child')
636
635
        unversion.unversion_file(file_id)
769
768
        replace = self.wt.transform()
770
769
        self.addCleanup(replace.finalize)
771
770
        name2 = replace.new_file('name2', root, [b'hello2'], b'name1')
772
 
        conflicts = replace.find_conflicts()
 
771
        conflicts = replace.find_raw_conflicts()
773
772
        name1 = replace.trans_id_tree_path('name1')
774
773
        self.assertEqual(conflicts, [('duplicate id', name1, name2)])
775
774
        resolve_conflicts(replace)
789
788
        transform.create_symlink(link_target2, wiz_id)
790
789
        transform.version_file(wiz_id, file_id=b'wiz-id2')
791
790
        transform.set_executability(True, wiz_id)
792
 
        self.assertEqual(transform.find_conflicts(),
 
791
        self.assertEqual(transform.find_raw_conflicts(),
793
792
                         [('non-file executability', wiz_id)])
794
793
        transform.set_executability(None, wiz_id)
795
794
        transform.apply()
818
817
            tt = wt.transform()
819
818
            self.addCleanup(tt.finalize)
820
819
            tt.new_symlink('foo', tt.root, 'bar')
821
 
            result = tt.find_conflicts()
 
820
            result = tt.find_raw_conflicts()
822
821
            self.assertEqual([], result)
823
822
        os_symlink = getattr(os, 'symlink', None)
824
823
        os.symlink = None
865
864
    def test_cook_conflicts(self):
866
865
        tt, emerald, oz, old_dorothy, new_dorothy = self.get_conflicted()
867
866
        raw_conflicts = resolve_conflicts(tt)
868
 
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
 
867
        cooked_conflicts = tt.cook_conflicts(raw_conflicts)
869
868
        duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved',
870
869
                                   'dorothy', None, b'dorothy-id')
871
870
        self.assertEqual(cooked_conflicts[0], duplicate)
895
894
    def test_string_conflicts(self):
896
895
        tt, emerald, oz, old_dorothy, new_dorothy = self.get_conflicted()
897
896
        raw_conflicts = resolve_conflicts(tt)
898
 
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
 
897
        cooked_conflicts = tt.cook_conflicts(raw_conflicts)
899
898
        tt.finalize()
900
899
        conflicts_s = [text_type(c) for c in cooked_conflicts]
901
900
        self.assertEqual(len(cooked_conflicts), len(conflicts_s))
928
927
        tt.new_file('child,', parent_id, [b'contents2'], b'file-id')
929
928
        return tt
930
929
 
931
 
    def test_find_conflicts_wrong_parent_kind(self):
 
930
    def test_find_raw_conflicts_wrong_parent_kind(self):
932
931
        tt = self.prepare_wrong_parent_kind()
933
 
        tt.find_conflicts()
 
932
        tt.find_raw_conflicts()
934
933
 
935
934
    def test_resolve_conflicts_wrong_existing_parent_kind(self):
936
935
        tt = self.prepare_wrong_parent_kind()
937
936
        raw_conflicts = resolve_conflicts(tt)
938
937
        self.assertEqual({('non-directory parent', 'Created directory',
939
938
                           'new-3')}, raw_conflicts)
940
 
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
 
939
        cooked_conflicts = tt.cook_conflicts(raw_conflicts)
941
940
        self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
942
941
                                             b'parent-id')], cooked_conflicts)
943
942
        tt.apply()