← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_conflicts.py

  • Committer: Jelmer Vernooij
  • Date: 2011-04-09 19:25:42 UTC
  • mto: (5777.5.1 inventoryworkingtree)
  • mto: This revision was merged to the branch mainline in revision 5781.
  • Revision ID: jelmer@samba.org-20110409192542-8bbedp36s7nj928e
Split InventoryTree out of Tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_conflicts.py
62
62
])
63
63
 
64
64
 
65
 
def vary_by_conflicts():
66
 
    for conflict in example_conflicts:
67
 
        yield (conflict.__class__.__name__, {"conflict": conflict})
68
 
 
69
 
 
70
65
class TestConflicts(tests.TestCaseWithTransport):
71
66
 
72
67
    def test_resolve_conflict_dir(self):
125
120
        self.assertEqual(conflicts.ConflictList([]), tree.conflicts())
126
121
 
127
122
 
128
 
class TestPerConflict(tests.TestCase):
129
 
 
130
 
    scenarios = scenarios.multiply_scenarios(vary_by_conflicts())
131
 
 
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__)
 
123
class TestConflictStanzas(tests.TestCase):
138
124
 
139
125
    def test_stanza_roundtrip(self):
140
 
        p = self.conflict
141
 
        o = conflicts.Conflict.factory(**p.as_stanza().as_dict())
142
 
        self.assertEqual(o, p)
143
 
 
144
 
        self.assertIsInstance(o.path, unicode)
145
 
 
146
 
        if o.file_id is not None:
147
 
            self.assertIsInstance(o.file_id, str)
148
 
 
149
 
        conflict_path = getattr(o, 'conflict_path', None)
150
 
        if conflict_path is not None:
151
 
            self.assertIsInstance(conflict_path, unicode)
152
 
 
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)
 
126
        # write and read our example stanza.
 
127
        stanza_iter = example_conflicts.to_stanzas()
 
128
        processed = conflicts.ConflictList.from_stanzas(stanza_iter)
 
129
        for o, p in zip(processed, example_conflicts):
 
130
            self.assertEqual(o, p)
 
131
 
 
132
            self.assertIsInstance(o.path, unicode)
 
133
 
 
134
            if o.file_id is not None:
 
135
                self.assertIsInstance(o.file_id, str)
 
136
 
 
137
            conflict_path = getattr(o, 'conflict_path', None)
 
138
            if conflict_path is not None:
 
139
                self.assertIsInstance(conflict_path, unicode)
 
140
 
 
141
            conflict_file_id = getattr(o, 'conflict_file_id', None)
 
142
            if conflict_file_id is not None:
 
143
                self.assertIsInstance(conflict_file_id, str)
156
144
 
157
145
    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')
167
 
 
168
 
 
169
 
class TestConflictList(tests.TestCase):
170
 
 
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)
175
 
 
176
 
    def test_stringification(self):
177
 
        for text, o in zip(example_conflicts.to_strings(), example_conflicts):
178
 
            self.assertEqual(text, unicode(o))
 
146
        for stanza in example_conflicts.to_stanzas():
 
147
            if 'file_id' in stanza:
 
148
                # In Stanza form, the file_id has to be unicode.
 
149
                self.assertStartsWith(stanza['file_id'], u'\xeed')
 
150
            self.assertStartsWith(stanza['path'], u'p\xe5th')
 
151
            if 'conflict_path' in stanza:
 
152
                self.assertStartsWith(stanza['conflict_path'], u'p\xe5th')
 
153
            if 'conflict_file_id' in stanza:
 
154
                self.assertStartsWith(stanza['conflict_file_id'], u'\xeed')
179
155
 
180
156
 
181
157
# FIXME: The shell-like tests should be converted to real whitebox tests... or
446
422
              dict(actions='modify_file', check='file_has_more_content')),
447
423
             ('file_deleted',
448
424
              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')),
455
 
             ('file_deleted',
456
 
              dict(actions='delete_file', check='file_doesnt_exist')),),
457
425
            # File modified/deleted in dir
458
426
            (dict(_base_actions='create_file_in_dir',
459
427
                  _path='dir/file', _file_id='file-id'),
471
439
    def do_modify_file(self):
472
440
        return [('modify', ('file-id', 'trunk content\nmore content\n'))]
473
441
 
474
 
    def do_modify_and_rename_file(self):
475
 
        return [('modify', ('file-id', 'trunk content\nmore content\n')),
476
 
                ('rename', ('file', 'new-file'))]
477
 
 
478
442
    def check_file_has_more_content(self):
479
443
        self.assertFileEqual('trunk content\nmore content\n', 'branch/file')
480
444
 
481
 
    def check_file_renamed_and_more_content(self):
482
 
        self.assertFileEqual('trunk content\nmore content\n', 'branch/new-file')
483
 
 
484
445
    def do_delete_file(self):
485
446
        return [('unversion', 'file-id')]
486
447
 
487
448
    def check_file_doesnt_exist(self):
488
 
        self.assertPathDoesNotExist('branch/file')
 
449
        self.failIfExists('branch/file')
489
450
 
490
451
    def do_create_file_in_dir(self):
491
452
        return [('add', ('dir', 'dir-id', 'directory', '')),
498
459
        self.assertFileEqual('trunk content\nmore content\n', 'branch/dir/file')
499
460
 
500
461
    def check_file_in_dir_doesnt_exist(self):
501
 
        self.assertPathDoesNotExist('branch/dir/file')
 
462
        self.failIfExists('branch/dir/file')
502
463
 
503
464
    def _get_resolve_path_arg(self, wt, action):
504
465
        return self._path
579
540
        return [('rename', ('file', 'new-file'))]
580
541
 
581
542
    def check_file_renamed(self):
582
 
        self.assertPathDoesNotExist('branch/file')
583
 
        self.assertPathExists('branch/new-file')
 
543
        self.failIfExists('branch/file')
 
544
        self.failUnlessExists('branch/new-file')
584
545
 
585
546
    def do_rename_file2(self):
586
547
        return [('rename', ('file', 'new-file2'))]
587
548
 
588
549
    def check_file_renamed2(self):
589
 
        self.assertPathDoesNotExist('branch/file')
590
 
        self.assertPathExists('branch/new-file2')
 
550
        self.failIfExists('branch/file')
 
551
        self.failUnlessExists('branch/new-file2')
591
552
 
592
553
    def do_rename_dir(self):
593
554
        return [('rename', ('dir', 'new-dir'))]
594
555
 
595
556
    def check_dir_renamed(self):
596
 
        self.assertPathDoesNotExist('branch/dir')
597
 
        self.assertPathExists('branch/new-dir')
 
557
        self.failIfExists('branch/dir')
 
558
        self.failUnlessExists('branch/new-dir')
598
559
 
599
560
    def do_rename_dir2(self):
600
561
        return [('rename', ('dir', 'new-dir2'))]
601
562
 
602
563
    def check_dir_renamed2(self):
603
 
        self.assertPathDoesNotExist('branch/dir')
604
 
        self.assertPathExists('branch/new-dir2')
 
564
        self.failIfExists('branch/dir')
 
565
        self.failUnlessExists('branch/new-dir2')
605
566
 
606
567
    def do_delete_file(self):
607
568
        return [('unversion', 'file-id')]
608
569
 
609
570
    def check_file_doesnt_exist(self):
610
 
        self.assertPathDoesNotExist('branch/file')
 
571
        self.failIfExists('branch/file')
611
572
 
612
573
    def do_delete_dir(self):
613
574
        return [('unversion', 'dir-id')]
614
575
 
615
576
    def check_dir_doesnt_exist(self):
616
 
        self.assertPathDoesNotExist('branch/dir')
 
577
        self.failIfExists('branch/dir')
617
578
 
618
579
    def do_create_file_in_dir(self):
619
580
        return [('add', ('dir', 'dir-id', 'directory', '')),
623
584
        return [('rename', ('dir/file', 'dir/new-file'))]
624
585
 
625
586
    def check_file_in_dir_renamed(self):
626
 
        self.assertPathDoesNotExist('branch/dir/file')
627
 
        self.assertPathExists('branch/dir/new-file')
 
587
        self.failIfExists('branch/dir/file')
 
588
        self.failUnlessExists('branch/dir/new-file')
628
589
 
629
590
    def check_file_in_dir_doesnt_exist(self):
630
 
        self.assertPathDoesNotExist('branch/dir/file')
 
591
        self.failIfExists('branch/dir/file')
631
592
 
632
593
    def _get_resolve_path_arg(self, wt, action):
633
594
        tpath = self._this['path']
741
702
        self.run_script("""
742
703
$ bzr rm -q dir  --force
743
704
$ bzr resolve dir
744
 
2>2 conflicts resolved, 0 remaining
 
705
2>2 conflict(s) resolved, 0 remaining
745
706
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
746
707
""")
747
708
 
748
709
    def test_take_other(self):
749
710
        self.run_script("""
750
711
$ bzr resolve dir
751
 
2>2 conflicts resolved, 0 remaining
 
712
2>2 conflict(s) resolved, 0 remaining
752
713
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
753
714
""")
754
715
 
782
743
    def test_keep_them_all(self):
783
744
        self.run_script("""
784
745
$ bzr resolve dir
785
 
2>2 conflicts resolved, 0 remaining
 
746
2>2 conflict(s) resolved, 0 remaining
786
747
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
787
748
""")
788
749
 
791
752
$ bzr mv -q dir/file2 file2
792
753
$ bzr rm -q dir --force
793
754
$ bzr resolve dir
794
 
2>2 conflicts resolved, 0 remaining
 
755
2>2 conflict(s) resolved, 0 remaining
795
756
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
796
757
""")
797
758
 
799
760
        self.run_script("""
800
761
$ bzr rm -q dir --force
801
762
$ bzr resolve dir
802
 
2>2 conflicts resolved, 0 remaining
 
763
2>2 conflict(s) resolved, 0 remaining
803
764
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
804
765
""")
805
766
 
846
807
    def test_keep_them_all(self):
847
808
        self.run_script("""
848
809
$ bzr resolve dir
849
 
2>2 conflicts resolved, 0 remaining
 
810
2>2 conflict(s) resolved, 0 remaining
850
811
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
851
812
""")
852
813
 
855
816
$ bzr mv -q dir/file2 file2
856
817
$ bzr rm -q dir --force
857
818
$ bzr resolve dir
858
 
2>2 conflicts resolved, 0 remaining
 
819
2>2 conflict(s) resolved, 0 remaining
859
820
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
860
821
""")
861
822
 
863
824
        self.run_script("""
864
825
$ bzr rm -q dir --force
865
826
$ bzr resolve dir
866
 
2>2 conflicts resolved, 0 remaining
 
827
2>2 conflict(s) resolved, 0 remaining
867
828
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
868
829
""")
869
830
 
870
831
    def test_resolve_taking_this(self):
871
832
        self.run_script("""
872
833
$ bzr resolve --take-this dir
873
 
2>2 conflicts resolved, 0 remaining
 
834
2>2 conflict(s) resolved, 0 remaining
874
835
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
875
836
""")
876
837
 
879
840
$ bzr resolve --take-other dir
880
841
2>deleted dir/file2
881
842
2>deleted dir
882
 
2>2 conflicts resolved, 0 remaining
 
843
2>2 conflict(s) resolved, 0 remaining
883
844
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
884
845
""")
885
846
 
924
885
        return [('rename', ('dir1', 'dir2/dir1'))]
925
886
 
926
887
    def check_dir1_moved(self):
927
 
        self.assertPathDoesNotExist('branch/dir1')
928
 
        self.assertPathExists('branch/dir2/dir1')
 
888
        self.failIfExists('branch/dir1')
 
889
        self.failUnlessExists('branch/dir2/dir1')
929
890
 
930
891
    def do_move_dir2_into_dir1(self):
931
892
        return [('rename', ('dir2', 'dir1/dir2'))]
932
893
 
933
894
    def check_dir2_moved(self):
934
 
        self.assertPathDoesNotExist('branch/dir2')
935
 
        self.assertPathExists('branch/dir1/dir2')
 
895
        self.failIfExists('branch/dir2')
 
896
        self.failUnlessExists('branch/dir1/dir2')
936
897
 
937
898
    def do_create_dir1_4(self):
938
899
        return [('add', ('dir1', 'dir1-id', 'directory', '')),
944
905
        return [('rename', ('dir1', 'dir3/dir4/dir1'))]
945
906
 
946
907
    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')
 
908
        self.failIfExists('branch/dir1')
 
909
        self.failUnlessExists('branch/dir3/dir4/dir1')
 
910
        self.failUnlessExists('branch/dir3/dir4/dir1/dir2')
950
911
 
951
912
    def do_move_dir3_into_dir2(self):
952
913
        return [('rename', ('dir3', 'dir1/dir2/dir3'))]
953
914
 
954
915
    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')
 
916
        self.failIfExists('branch/dir3')
 
917
        self.failUnlessExists('branch/dir1/dir2/dir3')
 
918
        self.failUnlessExists('branch/dir1/dir2/dir3/dir4')
958
919
 
959
920
    def _get_resolve_path_arg(self, wt, action):
960
921
        # ParentLoop says: moving <conflict_path> into <path>. Cancelled move.
971
932
        if self._other['xfail']:
972
933
            # It's a bit hackish to raise from here relying on being called for
973
934
            # both tests but this avoid overriding test_resolve_taking_other
974
 
            self.knownFailure(
 
935
            raise tests.KnownFailure(
975
936
                "ParentLoop doesn't carry enough info to resolve --take-other")
976
937
    _assert_conflict = assertParentLoop
977
938
 
1009
970
# aside ? -- vila 090916
1010
971
$ bzr add -q foo
1011
972
$ bzr resolve foo.new
1012
 
2>1 conflict resolved, 0 remaining
 
973
2>1 conflict(s) resolved, 0 remaining
1013
974
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
1014
975
""")
1015
976
 
1018
979
$ bzr rm -q foo --force
1019
980
$ bzr mv -q foo.new foo
1020
981
$ bzr resolve foo
1021
 
2>1 conflict resolved, 0 remaining
 
982
2>1 conflict(s) resolved, 0 remaining
1022
983
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
1023
984
""")
1024
985
 
1063
1024
""")
1064
1025
 
1065
1026
 
1066
 
class TestNoFinalPath(script.TestCaseWithTransportAndScript):
1067
 
 
1068
 
    def test_bug_805809(self):
1069
 
        self.run_script("""
1070
 
$ bzr init trunk
1071
 
Created a standalone tree (format: 2a)
1072
 
$ cd trunk
1073
 
$ echo trunk >file
1074
 
$ bzr add
1075
 
adding file
1076
 
$ bzr commit -m 'create file on trunk'
1077
 
2>Committing to: .../trunk/
1078
 
2>added file
1079
 
2>Committed revision 1.
1080
 
# Create a debian branch based on trunk
1081
 
$ cd ..
1082
 
$ bzr branch trunk -r 1 debian
1083
 
2>Branched 1 revision.
1084
 
$ cd debian
1085
 
$ mkdir dir
1086
 
$ bzr add
1087
 
adding dir
1088
 
$ bzr mv file dir
1089
 
file => dir/file
1090
 
$ bzr commit -m 'rename file to dir/file for debian'
1091
 
2>Committing to: .../debian/
1092
 
2>added dir
1093
 
2>renamed file => dir/file
1094
 
2>Committed revision 2.
1095
 
# Create an experimental branch with a new root-id
1096
 
$ cd ..
1097
 
$ bzr init experimental
1098
 
Created a standalone tree (format: 2a)
1099
 
$ cd experimental
1100
 
# Work around merging into empty branch not being supported
1101
 
# (http://pad.lv/308562)
1102
 
$ echo something >not-empty
1103
 
$ bzr add
1104
 
adding not-empty
1105
 
$ bzr commit -m 'Add some content in experimental'
1106
 
2>Committing to: .../experimental/
1107
 
2>added not-empty
1108
 
2>Committed revision 1.
1109
 
# merge debian even without a common ancestor
1110
 
$ bzr merge ../debian -r0..2
1111
 
2>+N  dir/
1112
 
2>+N  dir/file
1113
 
2>All changes applied successfully.
1114
 
$ bzr commit -m 'merging debian into experimental'
1115
 
2>Committing to: .../experimental/
1116
 
2>added dir
1117
 
2>added dir/file
1118
 
2>Committed revision 2.
1119
 
# Create an ubuntu branch with yet another root-id
1120
 
$ cd ..
1121
 
$ bzr init ubuntu
1122
 
Created a standalone tree (format: 2a)
1123
 
$ cd ubuntu
1124
 
# Work around merging into empty branch not being supported
1125
 
# (http://pad.lv/308562)
1126
 
$ echo something >not-empty-ubuntu
1127
 
$ bzr add
1128
 
adding not-empty-ubuntu
1129
 
$ bzr commit -m 'Add some content in experimental'
1130
 
2>Committing to: .../ubuntu/
1131
 
2>added not-empty-ubuntu
1132
 
2>Committed revision 1.
1133
 
# Also merge debian
1134
 
$ bzr merge ../debian -r0..2
1135
 
2>+N  dir/
1136
 
2>+N  dir/file
1137
 
2>All changes applied successfully.
1138
 
$ bzr commit -m 'merging debian'
1139
 
2>Committing to: .../ubuntu/
1140
 
2>added dir
1141
 
2>added dir/file
1142
 
2>Committed revision 2.
1143
 
# Now try to merge experimental
1144
 
$ bzr merge ../experimental
1145
 
2>+N  not-empty
1146
 
2>Path conflict: dir / dir
1147
 
2>1 conflicts encountered.
1148
 
""")
1149
 
 
1150
 
 
1151
1027
class TestResolveActionOption(tests.TestCase):
1152
1028
 
1153
1029
    def setUp(self):