/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

Some improvements for transform and tests for GitTransform.

Merged from https://code.launchpad.net/~jelmer/brz/transform-1/+merge/389367

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/per_workingtree/test_transform.py
91
91
 
92
92
    def transform_for_sha1_test(self):
93
93
        trans, root = self.transform()
 
94
        if getattr(self.wt, '_observed_sha1', None) is None:
 
95
            raise tests.TestNotApplicable(
 
96
                'wt format does not use _observed_sha1')
94
97
        self.wt.lock_tree_write()
95
98
        self.addCleanup(self.wt.unlock)
96
99
        contents = [b'just some content\n']
133
136
        self.assertEqual(imaginary_id, imaginary_id2)
134
137
        self.assertEqual(root, transform.get_tree_parent(imaginary_id))
135
138
        self.assertEqual('directory', transform.final_kind(root))
136
 
        self.assertEqual(self.wt.path2id(''), transform.final_file_id(root))
 
139
        if self.wt.supports_setting_file_ids():
 
140
            self.assertEqual(self.wt.path2id(''), transform.final_file_id(root))
137
141
        trans_id = transform.create_path('name', root)
138
 
        self.assertIs(transform.final_file_id(trans_id), None)
 
142
        if self.wt.supports_setting_file_ids():
 
143
            self.assertIs(transform.final_file_id(trans_id), None)
 
144
        self.assertFalse(transform.final_is_versioned(trans_id))
139
145
        self.assertIs(None, transform.final_kind(trans_id))
140
146
        transform.create_file([b'contents'], trans_id)
141
147
        transform.set_executability(True, trans_id)
142
148
        transform.version_file(trans_id, file_id=b'my_pretties')
143
149
        self.assertRaises(DuplicateKey, transform.version_file,
144
150
                          trans_id, file_id=b'my_pretties')
145
 
        self.assertEqual(transform.final_file_id(trans_id), b'my_pretties')
 
151
        if self.wt.supports_setting_file_ids():
 
152
            self.assertEqual(transform.final_file_id(trans_id), b'my_pretties')
 
153
        self.assertTrue(transform.final_is_versioned(trans_id))
146
154
        self.assertEqual(transform.final_parent(trans_id), root)
147
155
        self.assertIs(transform.final_parent(root), ROOT_PARENT)
148
156
        self.assertIs(transform.get_tree_parent(root), ROOT_PARENT)
156
164
        modified_paths = transform.apply().modified_paths
157
165
        with self.wt.get_file('name') as f:
158
166
            self.assertEqual(b'contents', f.read())
159
 
        self.assertEqual(self.wt.path2id('name'), b'my_pretties')
 
167
        if self.wt.supports_setting_file_ids():
 
168
            self.assertEqual(self.wt.path2id('name'), b'my_pretties')
160
169
        self.assertIs(self.wt.is_executable('name'), True)
161
170
        self.assertIs(self.wt.is_executable('name2'), False)
162
171
        self.assertEqual('directory', file_kind(self.wt.abspath('oz')))
163
172
        self.assertEqual(len(modified_paths), 3)
164
 
        tree_mod_paths = [self.wt.abspath(self.wt.id2path(f)) for f in
165
 
                          (b'ozzie', b'my_pretties', b'my_pretties2')]
166
 
        self.assertSubset(tree_mod_paths, modified_paths)
 
173
        if self.wt.supports_setting_file_ids():
 
174
            tree_mod_paths = [self.wt.abspath(self.wt.id2path(f)) for f in
 
175
                              (b'ozzie', b'my_pretties', b'my_pretties2')]
 
176
            self.assertSubset(tree_mod_paths, modified_paths)
167
177
        # is it safe to finalize repeatedly?
168
178
        transform.finalize()
169
179
        transform.finalize()
303
313
        with tt:
304
314
            tt.new_directory('', ROOT_PARENT, b'new-root-id')
305
315
            tt.fixup_new_roots()
306
 
            self.assertNotEqual(b'new-root-id', tt.final_file_id(tt.root))
 
316
            if self.wt.has_versioned_directories():
 
317
                self.assertTrue(tt.final_is_versioned(tt.root))
 
318
            if self.wt.supports_setting_file_ids():
 
319
                self.assertNotEqual(b'new-root-id', tt.final_file_id(tt.root))
307
320
 
308
321
    def test_retain_existing_root_added_file(self):
309
322
        tt, root = self.transform()
340
353
        transform.unversion_file(root)
341
354
        transform.fixup_new_roots()
342
355
        self.assertIs(None, transform.final_kind(root))
343
 
        self.assertIs(None, transform.final_file_id(root))
 
356
        if self.wt.supports_setting_file_ids():
 
357
            self.assertIs(None, transform.final_file_id(root))
344
358
 
345
359
    def test_apply_retains_root_directory(self):
346
360
        # Do not attempt to delete the physical root directory, because that
355
369
 
356
370
    def test_apply_retains_file_id(self):
357
371
        transform, root = self.transform()
 
372
        if not self.wt.supports_setting_file_ids():
 
373
            self.skipTest('format does not support file ids')
358
374
        old_root_id = transform.tree_file_id(root)
359
375
        transform.unversion_file(root)
360
376
        transform.apply()
390
406
        self.assertRaises(ReusingTransform, transform.find_raw_conflicts)
391
407
        with open(self.wt.abspath('name'), 'r') as f:
392
408
            self.assertEqual('contents', f.read())
393
 
        self.assertEqual(self.wt.path2id('name'), b'my_pretties')
394
409
        self.assertIs(self.wt.is_executable('name'), True)
395
 
        self.assertEqual(self.wt.path2id('oz'), b'oz-id')
396
 
        self.assertEqual(self.wt.path2id('oz/dorothy'), b'dorothy-id')
397
 
        self.assertEqual(self.wt.path2id('oz/dorothy/toto'), b'toto-id')
 
410
        self.assertTrue(self.wt.is_versioned('name'))
 
411
        self.assertTrue(self.wt.is_versioned('oz'))
 
412
        self.assertTrue(self.wt.is_versioned('oz/dorothy'))
 
413
        self.assertTrue(self.wt.is_versioned('oz/dorothy/toto'))
 
414
        if self.wt.supports_setting_file_ids():
 
415
            self.assertEqual(self.wt.path2id('name'), b'my_pretties')
 
416
            self.assertEqual(self.wt.path2id('oz'), b'oz-id')
 
417
            self.assertEqual(self.wt.path2id('oz/dorothy'), b'dorothy-id')
 
418
            self.assertEqual(self.wt.path2id('oz/dorothy/toto'), b'toto-id')
398
419
 
399
 
        self.assertEqual(b'toto-contents',
400
 
                         self.wt.get_file('oz/dorothy/toto').read())
 
420
        with self.wt.get_file('oz/dorothy/toto') as f:
 
421
            self.assertEqual(b'toto-contents', f.read())
401
422
        self.assertIs(self.wt.is_executable('oz/dorothy/toto'), False)
402
423
 
403
424
    def test_tree_reference(self):
464
485
        transform.set_executability(None, oz_id)
465
486
        tip_id = transform.new_file('tip', oz_id, [b'ozma'], b'tip-id')
466
487
        transform.apply()
467
 
        self.assertEqual(self.wt.path2id('name'), b'my_pretties')
 
488
        if self.wt.supports_setting_file_ids():
 
489
            self.assertEqual(self.wt.path2id('name'), b'my_pretties')
468
490
        with open(self.wt.abspath('name'), 'rb') as f:
469
491
            self.assertEqual(b'contents', f.read())
470
492
        transform2, root = self.transform()
629
651
        self.addCleanup(unversion.finalize)
630
652
        parent = unversion.trans_id_tree_path('parent')
631
653
        unversion.unversion_file(parent)
632
 
        self.assertEqual(unversion.find_raw_conflicts(),
633
 
                         [('unversioned parent', parent_id)])
 
654
        if self.wt.has_versioned_directories():
 
655
            self.assertEqual(unversion.find_raw_conflicts(),
 
656
                             [('unversioned parent', parent_id)])
 
657
        else:
 
658
            self.assertEqual(unversion.find_raw_conflicts(), [])
634
659
        file_id = unversion.trans_id_tree_path('parent/child')
635
660
        unversion.unversion_file(file_id)
636
661
        unversion.apply()
669
694
        mfile2 = mangle_tree.trans_id_tree_path('moving_file2')
670
695
        mangle_tree.adjust_path('mfile2', newdir, mfile2)
671
696
        mangle_tree.new_file('newfile', newdir, [b'hello3'], b'dfile')
672
 
        self.assertEqual(mangle_tree.final_file_id(mfile2), b'mfile2')
 
697
        if self.wt.supports_setting_file_ids():
 
698
            self.assertEqual(mangle_tree.final_file_id(mfile2), b'mfile2')
673
699
        self.assertEqual(mangle_tree.final_parent(mfile2), newdir)
674
 
        self.assertEqual(mangle_tree.final_file_id(mfile2), b'mfile2')
675
700
        mangle_tree.apply()
676
701
        with open(self.wt.abspath('name1'), 'r') as f:
677
702
            self.assertEqual(f.read(), 'hello2')
681
706
        self.assertEqual(mangle_tree.final_parent(mfile2), newdir)
682
707
        with open(mfile2_path, 'r') as f:
683
708
            self.assertEqual(f.read(), 'later2')
684
 
        self.assertEqual(self.wt.id2path(b'mfile2'), 'new_directory/mfile2')
685
 
        self.assertEqual(self.wt.path2id('new_directory/mfile2'), b'mfile2')
 
709
        if self.wt.supports_setting_file_ids():
 
710
            self.assertEqual(self.wt.id2path(b'mfile2'), 'new_directory/mfile2')
 
711
            self.assertEqual(self.wt.path2id('new_directory/mfile2'), b'mfile2')
686
712
        newfile_path = self.wt.abspath(pathjoin('new_directory', 'newfile'))
687
713
        with open(newfile_path, 'r') as f:
688
714
            self.assertEqual(f.read(), 'hello3')
689
 
        self.assertEqual(self.wt.path2id('dying_directory'), b'ddir')
690
 
        self.assertIs(self.wt.path2id('dying_directory/dying_file'), None)
 
715
        if self.wt.supports_setting_file_ids():
 
716
            self.assertEqual(self.wt.path2id('dying_directory'), b'ddir')
 
717
            self.assertIs(self.wt.path2id('dying_directory/dying_file'), None)
691
718
        mfile2_path = self.wt.abspath(pathjoin('new_directory', 'mfile2'))
692
719
 
693
720
    def test_both_rename(self):
770
797
        name2 = replace.new_file('name2', root, [b'hello2'], b'name1')
771
798
        conflicts = replace.find_raw_conflicts()
772
799
        name1 = replace.trans_id_tree_path('name1')
773
 
        self.assertEqual(conflicts, [('duplicate id', name1, name2)])
 
800
        if self.wt.supports_setting_file_ids():
 
801
            self.assertEqual(conflicts, [('duplicate id', name1, name2)])
 
802
        else:
 
803
            self.assertEqual(conflicts, [])
774
804
        resolve_conflicts(replace)
775
805
        replace.apply()
776
806
 
792
822
                         [('non-file executability', wiz_id)])
793
823
        transform.set_executability(None, wiz_id)
794
824
        transform.apply()
795
 
        self.assertEqual(self.wt.path2id(ozpath(link_name1)), b'wizard-id')
 
825
        if self.wt.supports_setting_file_ids():
 
826
            self.assertEqual(self.wt.path2id(ozpath(link_name1)), b'wizard-id')
796
827
        self.assertEqual('symlink',
797
828
                         file_kind(self.wt.abspath(ozpath(link_name1))))
798
829
        self.assertEqual(link_target2,
923
954
        tt.new_file('parent', root, [b'contents'], b'parent-id')
924
955
        tt.apply()
925
956
        tt, root = self.transform()
926
 
        parent_id = tt.trans_id_file_id(b'parent-id')
 
957
        parent_id = tt.trans_id_tree_path('parent')
927
958
        tt.new_file('child,', parent_id, [b'contents2'], b'file-id')
928
959
        return tt
929
960
 
937
968
        self.assertEqual({('non-directory parent', 'Created directory',
938
969
                           'new-3')}, raw_conflicts)
939
970
        cooked_conflicts = tt.cook_conflicts(raw_conflicts)
940
 
        self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
941
 
                                             b'parent-id')], cooked_conflicts)
 
971
        if self.wt.supports_setting_file_ids():
 
972
            self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
 
973
                                                 b'parent-id')], cooked_conflicts)
 
974
        else:
 
975
            self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
 
976
                                                 None)], cooked_conflicts)
942
977
        tt.apply()
943
 
        self.assertFalse(self.wt.is_versioned('parent'))
944
 
        self.assertEqual(b'parent-id', self.wt.path2id('parent.new'))
 
978
        if self.wt.has_versioned_directories():
 
979
            self.assertFalse(self.wt.is_versioned('parent'))
 
980
        if self.wt.supports_setting_file_ids():
 
981
            self.assertEqual(b'parent-id', self.wt.path2id('parent.new'))
945
982
 
946
983
    def test_resolve_conflicts_wrong_new_parent_kind(self):
947
984
        tt, root = self.transform()
949
986
        tt.new_file('child,', parent_id, [b'contents2'], b'file-id')
950
987
        tt.apply()
951
988
        tt, root = self.transform()
952
 
        parent_id = tt.trans_id_file_id(b'parent-id')
 
989
        parent_id = tt.trans_id_tree_path('parent')
953
990
        tt.delete_contents(parent_id)
954
991
        tt.create_file([b'contents'], parent_id)
955
992
        raw_conflicts = resolve_conflicts(tt)
956
993
        self.assertEqual({('non-directory parent', 'Created directory',
957
994
                           'new-3')}, raw_conflicts)
958
995
        tt.apply()
959
 
        self.assertFalse(self.wt.is_versioned('parent'))
960
 
        self.assertEqual(b'parent-id', self.wt.path2id('parent.new'))
 
996
        if self.wt.has_versioned_directories():
 
997
            self.assertFalse(self.wt.is_versioned('parent'))
 
998
            self.assertTrue(self.wt.is_versioned('parent.new'))
 
999
        if self.wt.supports_setting_file_ids():
 
1000
            self.assertEqual(b'parent-id', self.wt.path2id('parent.new'))
961
1001
 
962
1002
    def test_resolve_conflicts_wrong_parent_kind_unversioned(self):
963
1003
        tt, root = self.transform()
970
1010
        tt.create_file([b'contents'], parent_id)
971
1011
        resolve_conflicts(tt)
972
1012
        tt.apply()
973
 
        self.assertFalse(self.wt.is_versioned('parent'))
974
 
        self.assertFalse(self.wt.is_versioned('parent.new'))
 
1013
        if self.wt.has_versioned_directories():
 
1014
            self.assertFalse(self.wt.is_versioned('parent'))
 
1015
            self.assertFalse(self.wt.is_versioned('parent.new'))
975
1016
 
976
1017
    def test_resolve_conflicts_missing_parent(self):
977
1018
        wt = self.make_branch_and_tree('.')
978
1019
        tt = wt.transform()
979
1020
        self.addCleanup(tt.finalize)
980
 
        parent = tt.trans_id_file_id(b'parent-id')
 
1021
        parent = tt.assign_id()
981
1022
        tt.new_file('file', parent, [b'Contents'])
982
1023
        raw_conflicts = resolve_conflicts(tt)
983
1024
        # Since the directory doesn't exist it's seen as 'missing'.  So
1020
1061
                                 b'myfile-id')
1021
1062
        create.apply()
1022
1063
        rename, root = self.transform()
1023
 
        old = rename.trans_id_file_id(b'old-id')
 
1064
        old = rename.trans_id_tree_path('old-parent')
1024
1065
        rename.adjust_path('new', root, old)
1025
 
        myfile = rename.trans_id_file_id(b'myfile-id')
 
1066
        myfile = rename.trans_id_tree_path('old-parent/intermediate/myfile')
1026
1067
        rename.set_executability(True, myfile)
1027
1068
        rename.apply()
1028
1069
 
1043
1084
            self.skipTest("Can't force a permissions error on rename")
1044
1085
        # now transform to rename
1045
1086
        rename_transform, root_id = self.transform()
1046
 
        file_trans_id = rename_transform.trans_id_file_id(b'myfile-id')
1047
 
        dir_id = rename_transform.trans_id_file_id(b'first-id')
 
1087
        file_trans_id = rename_transform.trans_id_tree_path('myfile')
 
1088
        dir_id = rename_transform.trans_id_tree_path('first-dir')
1048
1089
        rename_transform.adjust_path('newname', dir_id, file_trans_id)
1049
1090
        e = self.assertRaises(TransformRenameFailed,
1050
1091
                              rename_transform.apply)
1418
1459
    def test_noname_contents(self):
1419
1460
        """TreeTransform should permit deferring naming files."""
1420
1461
        transform, root = self.transform()
1421
 
        parent = transform.trans_id_file_id(b'parent-id')
 
1462
        parent = transform.trans_id_tree_path('parent')
1422
1463
        try:
1423
1464
            transform.create_directory(parent)
1424
1465
        except KeyError:
1428
1469
    def test_noname_contents_nested(self):
1429
1470
        """TreeTransform should permit deferring naming files."""
1430
1471
        transform, root = self.transform()
1431
 
        parent = transform.trans_id_file_id(b'parent-id')
 
1472
        parent = transform.trans_id_tree_path('parent-early')
1432
1473
        try:
1433
1474
            transform.create_directory(parent)
1434
1475
        except KeyError:
1653
1694
 
1654
1695
    def test_no_final_path(self):
1655
1696
        transform, root = self.transform()
1656
 
        trans_id = transform.trans_id_file_id(b'foo')
 
1697
        trans_id = transform.trans_id_tree_path('foo')
1657
1698
        transform.create_file([b'bar'], trans_id)
1658
1699
        transform.cancel_creation(trans_id)
1659
1700
        transform.apply()