/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

  • 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/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,
58
58
    )
59
59
from ...transform import (
60
60
    create_from_tree,
61
 
    cook_conflicts,
62
61
    FinalPaths,
63
62
    resolve_conflicts,
64
63
    resolve_checkout,
383
382
        transform.new_file('toto', dorothy, [b'toto-contents'], b'toto-id',
384
383
                           False)
385
384
 
386
 
        self.assertEqual(len(transform.find_conflicts()), 0)
 
385
        self.assertEqual(len(transform.find_raw_conflicts()), 0)
387
386
        transform.apply()
388
 
        self.assertRaises(ReusingTransform, transform.find_conflicts)
 
387
        self.assertRaises(ReusingTransform, transform.find_raw_conflicts)
389
388
        with open(self.wt.abspath('name'), 'r') as f:
390
389
            self.assertEqual('contents', f.read())
391
390
        self.assertEqual(self.wt.path2id('name'), b'my_pretties')
418
417
        transform, root = self.transform()
419
418
        trans_id = transform.new_file('name', root, [b'contents'],
420
419
                                      b'my_pretties')
421
 
        self.assertEqual(len(transform.find_conflicts()), 0)
 
420
        self.assertEqual(len(transform.find_raw_conflicts()), 0)
422
421
        trans_id2 = transform.new_file('name', root, [b'Crontents'], b'toto')
423
 
        self.assertEqual(transform.find_conflicts(),
 
422
        self.assertEqual(transform.find_raw_conflicts(),
424
423
                         [('duplicate', trans_id, trans_id2, 'name')])
425
424
        self.assertRaises(MalformedTransform, transform.apply)
426
425
        transform.adjust_path('name', trans_id, trans_id2)
427
 
        self.assertEqual(transform.find_conflicts(),
 
426
        self.assertEqual(transform.find_raw_conflicts(),
428
427
                         [('non-directory parent', trans_id)])
429
428
        tinman_id = transform.trans_id_tree_path('tinman')
430
429
        transform.adjust_path('name', tinman_id, trans_id2)
431
 
        self.assertEqual(transform.find_conflicts(),
 
430
        self.assertEqual(transform.find_raw_conflicts(),
432
431
                         [('unversioned parent', tinman_id),
433
432
                          ('missing parent', tinman_id)])
434
433
        lion_id = transform.create_path('lion', root)
435
 
        self.assertEqual(transform.find_conflicts(),
 
434
        self.assertEqual(transform.find_raw_conflicts(),
436
435
                         [('unversioned parent', tinman_id),
437
436
                          ('missing parent', tinman_id)])
438
437
        transform.adjust_path('name', lion_id, trans_id2)
439
 
        self.assertEqual(transform.find_conflicts(),
 
438
        self.assertEqual(transform.find_raw_conflicts(),
440
439
                         [('unversioned parent', lion_id),
441
440
                          ('missing parent', lion_id)])
442
441
        transform.version_file(lion_id, file_id=b"Courage")
443
 
        self.assertEqual(transform.find_conflicts(),
 
442
        self.assertEqual(transform.find_raw_conflicts(),
444
443
                         [('missing parent', lion_id),
445
444
                          ('versioning no contents', lion_id)])
446
445
        transform.adjust_path('name2', root, trans_id2)
447
 
        self.assertEqual(transform.find_conflicts(),
 
446
        self.assertEqual(transform.find_raw_conflicts(),
448
447
                         [('versioning no contents', lion_id)])
449
448
        transform.create_file([b'Contents, okay?'], lion_id)
450
449
        transform.adjust_path('name2', trans_id2, trans_id2)
451
 
        self.assertEqual(transform.find_conflicts(),
 
450
        self.assertEqual(transform.find_raw_conflicts(),
452
451
                         [('parent loop', trans_id2),
453
452
                          ('non-directory parent', trans_id2)])
454
453
        transform.adjust_path('name2', root, trans_id2)
455
454
        oz_id = transform.new_directory('oz', root)
456
455
        transform.set_executability(True, oz_id)
457
 
        self.assertEqual(transform.find_conflicts(),
 
456
        self.assertEqual(transform.find_raw_conflicts(),
458
457
                         [('unversioned executability', oz_id)])
459
458
        transform.version_file(oz_id, file_id=b'oz-id')
460
 
        self.assertEqual(transform.find_conflicts(),
 
459
        self.assertEqual(transform.find_raw_conflicts(),
461
460
                         [('non-file executability', oz_id)])
462
461
        transform.set_executability(None, oz_id)
463
462
        tip_id = transform.new_file('tip', oz_id, [b'ozma'], b'tip-id')
468
467
        transform2, root = self.transform()
469
468
        oz_id = transform2.trans_id_tree_path('oz')
470
469
        newtip = transform2.new_file('tip', oz_id, [b'other'], b'tip-id')
471
 
        result = transform2.find_conflicts()
 
470
        result = transform2.find_raw_conflicts()
472
471
        fp = FinalPaths(transform2)
473
472
        self.assertTrue('oz/tip' in transform2._tree_path_ids)
474
473
        self.assertEqual(fp.get_path(newtip), pathjoin('oz', 'tip'))
482
481
        self.addCleanup(transform3.finalize)
483
482
        oz_id = transform3.trans_id_tree_path('oz')
484
483
        transform3.delete_contents(oz_id)
485
 
        self.assertEqual(transform3.find_conflicts(),
 
484
        self.assertEqual(transform3.find_raw_conflicts(),
486
485
                         [('missing parent', oz_id)])
487
486
        root_id = transform3.root
488
487
        tip_id = transform3.trans_id_tree_path('oz/tip')
499
498
        self.addCleanup(transform.finalize)
500
499
        transform.new_file('file', transform.root, [b'content'])
501
500
        transform.new_file('FiLe', transform.root, [b'content'])
502
 
        result = transform.find_conflicts()
 
501
        result = transform.find_raw_conflicts()
503
502
        self.assertEqual([], result)
504
503
        transform.finalize()
505
504
        # Force the tree to report that it is case insensitive, for conflict
509
508
        self.addCleanup(transform.finalize)
510
509
        transform.new_file('file', transform.root, [b'content'])
511
510
        transform.new_file('FiLe', transform.root, [b'content'])
512
 
        result = transform.find_conflicts()
 
511
        result = transform.find_raw_conflicts()
513
512
        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
514
513
 
515
514
    def test_conflict_on_case_insensitive_existing(self):
522
521
        transform = tree.transform()
523
522
        self.addCleanup(transform.finalize)
524
523
        transform.new_file('file', transform.root, [b'content'])
525
 
        result = transform.find_conflicts()
 
524
        result = transform.find_raw_conflicts()
526
525
        self.assertEqual([], result)
527
526
        transform.finalize()
528
527
        # Force the tree to report that it is case insensitive, for conflict
531
530
        transform = tree.transform()
532
531
        self.addCleanup(transform.finalize)
533
532
        transform.new_file('file', transform.root, [b'content'])
534
 
        result = transform.find_conflicts()
 
533
        result = transform.find_raw_conflicts()
535
534
        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
536
535
 
537
536
    def test_resolve_case_insensitive_conflict(self):
627
626
        self.addCleanup(unversion.finalize)
628
627
        parent = unversion.trans_id_tree_path('parent')
629
628
        unversion.unversion_file(parent)
630
 
        self.assertEqual(unversion.find_conflicts(),
 
629
        self.assertEqual(unversion.find_raw_conflicts(),
631
630
                         [('unversioned parent', parent_id)])
632
631
        file_id = unversion.trans_id_tree_path('parent/child')
633
632
        unversion.unversion_file(file_id)
766
765
        replace = self.wt.transform()
767
766
        self.addCleanup(replace.finalize)
768
767
        name2 = replace.new_file('name2', root, [b'hello2'], b'name1')
769
 
        conflicts = replace.find_conflicts()
 
768
        conflicts = replace.find_raw_conflicts()
770
769
        name1 = replace.trans_id_tree_path('name1')
771
770
        self.assertEqual(conflicts, [('duplicate id', name1, name2)])
772
771
        resolve_conflicts(replace)
786
785
        transform.create_symlink(link_target2, wiz_id)
787
786
        transform.version_file(wiz_id, file_id=b'wiz-id2')
788
787
        transform.set_executability(True, wiz_id)
789
 
        self.assertEqual(transform.find_conflicts(),
 
788
        self.assertEqual(transform.find_raw_conflicts(),
790
789
                         [('non-file executability', wiz_id)])
791
790
        transform.set_executability(None, wiz_id)
792
791
        transform.apply()
815
814
            tt = wt.transform()
816
815
            self.addCleanup(tt.finalize)
817
816
            tt.new_symlink('foo', tt.root, 'bar')
818
 
            result = tt.find_conflicts()
 
817
            result = tt.find_raw_conflicts()
819
818
            self.assertEqual([], result)
820
819
        os_symlink = getattr(os, 'symlink', None)
821
820
        os.symlink = None
862
861
    def test_cook_conflicts(self):
863
862
        tt, emerald, oz, old_dorothy, new_dorothy = self.get_conflicted()
864
863
        raw_conflicts = resolve_conflicts(tt)
865
 
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
 
864
        cooked_conflicts = tt.cook_conflicts(raw_conflicts)
866
865
        duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved',
867
866
                                   'dorothy', None, b'dorothy-id')
868
867
        self.assertEqual(cooked_conflicts[0], duplicate)
892
891
    def test_string_conflicts(self):
893
892
        tt, emerald, oz, old_dorothy, new_dorothy = self.get_conflicted()
894
893
        raw_conflicts = resolve_conflicts(tt)
895
 
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
 
894
        cooked_conflicts = tt.cook_conflicts(raw_conflicts)
896
895
        tt.finalize()
897
896
        conflicts_s = [str(c) for c in cooked_conflicts]
898
897
        self.assertEqual(len(cooked_conflicts), len(conflicts_s))
925
924
        tt.new_file('child,', parent_id, [b'contents2'], b'file-id')
926
925
        return tt
927
926
 
928
 
    def test_find_conflicts_wrong_parent_kind(self):
 
927
    def test_find_raw_conflicts_wrong_parent_kind(self):
929
928
        tt = self.prepare_wrong_parent_kind()
930
 
        tt.find_conflicts()
 
929
        tt.find_raw_conflicts()
931
930
 
932
931
    def test_resolve_conflicts_wrong_existing_parent_kind(self):
933
932
        tt = self.prepare_wrong_parent_kind()
934
933
        raw_conflicts = resolve_conflicts(tt)
935
934
        self.assertEqual({('non-directory parent', 'Created directory',
936
935
                           'new-3')}, raw_conflicts)
937
 
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
 
936
        cooked_conflicts = tt.cook_conflicts(raw_conflicts)
938
937
        self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
939
938
                                             b'parent-id')], cooked_conflicts)
940
939
        tt.apply()