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

  • Committer: Jelmer Vernooij
  • Date: 2019-06-03 23:48:08 UTC
  • mfrom: (7316 work)
  • mto: This revision was merged to the branch mainline in revision 7328.
  • Revision ID: jelmer@jelmer.uk-20190603234808-15yk5c7054tj8e2b
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_transform.py
16
16
 
17
17
import codecs
18
18
import errno
19
 
from io import BytesIO, StringIO
20
19
import os
21
20
import sys
22
21
import time
147
146
        self.assertEqual(imaginary_id, imaginary_id2)
148
147
        self.assertEqual(root, transform.get_tree_parent(imaginary_id))
149
148
        self.assertEqual('directory', transform.final_kind(root))
150
 
        self.assertEqual(self.wt.path2id(''), transform.final_file_id(root))
 
149
        self.assertEqual(self.wt.get_root_id(), transform.final_file_id(root))
151
150
        trans_id = transform.create_path('name', root)
152
151
        self.assertIs(transform.final_file_id(trans_id), None)
153
152
        self.assertIs(None, transform.final_kind(trans_id))
270
269
 
271
270
    def test_change_root_id(self):
272
271
        transform, root = self.get_transform()
273
 
        self.assertNotEqual(b'new-root-id', self.wt.path2id(''))
 
272
        self.assertNotEqual(b'new-root-id', self.wt.get_root_id())
274
273
        transform.new_directory('', ROOT_PARENT, b'new-root-id')
275
274
        transform.delete_contents(root)
276
275
        transform.unversion_file(root)
277
276
        transform.fixup_new_roots()
278
277
        transform.apply()
279
 
        self.assertEqual(b'new-root-id', self.wt.path2id(''))
 
278
        self.assertEqual(b'new-root-id', self.wt.get_root_id())
280
279
 
281
280
    def test_change_root_id_add_files(self):
282
281
        transform, root = self.get_transform()
283
 
        self.assertNotEqual(b'new-root-id', self.wt.path2id(''))
 
282
        self.assertNotEqual(b'new-root-id', self.wt.get_root_id())
284
283
        new_trans_id = transform.new_directory('', ROOT_PARENT, b'new-root-id')
285
284
        transform.new_file('file', new_trans_id, [b'new-contents\n'],
286
285
                           b'new-file-id')
288
287
        transform.unversion_file(root)
289
288
        transform.fixup_new_roots()
290
289
        transform.apply()
291
 
        self.assertEqual(b'new-root-id', self.wt.path2id(''))
 
290
        self.assertEqual(b'new-root-id', self.wt.get_root_id())
292
291
        self.assertEqual(b'new-file-id', self.wt.path2id('file'))
293
292
        self.assertFileEqual(b'new-contents\n', self.wt.abspath('file'))
294
293
 
321
320
 
322
321
    def test_remove_root_fixup(self):
323
322
        transform, root = self.get_transform()
324
 
        old_root_id = self.wt.path2id('')
 
323
        old_root_id = self.wt.get_root_id()
325
324
        self.assertNotEqual(b'new-root-id', old_root_id)
326
325
        transform.delete_contents(root)
327
326
        transform.unversion_file(root)
328
327
        transform.fixup_new_roots()
329
328
        transform.apply()
330
 
        self.assertEqual(old_root_id, self.wt.path2id(''))
 
329
        self.assertEqual(old_root_id, self.wt.get_root_id())
331
330
 
332
331
        transform, root = self.get_transform()
333
332
        transform.new_directory('', ROOT_PARENT, b'new-root-id')
358
357
        old_root_id = transform.tree_file_id(root)
359
358
        transform.unversion_file(root)
360
359
        transform.apply()
361
 
        self.assertEqual(old_root_id, self.wt.path2id(''))
 
360
        self.assertEqual(old_root_id, self.wt.get_root_id())
362
361
 
363
362
    def test_hardlink(self):
364
363
        self.requireFeature(HardlinkFeature)
807
806
                            u'\N{Euro Sign}wizard2',
808
807
                            u'b\N{Euro Sign}hind_curtain')
809
808
 
810
 
    def test_unsupported_symlink_no_conflict(self):
 
809
    def test_unable_create_symlink(self):
811
810
        def tt_helper():
812
811
            wt = self.make_branch_and_tree('.')
813
 
            tt = TreeTransform(wt)
814
 
            self.addCleanup(tt.finalize)
815
 
            tt.new_symlink('foo', tt.root, 'bar')
816
 
            result = tt.find_conflicts()
817
 
            self.assertEqual([], result)
 
812
            tt = TreeTransform(wt)  # TreeTransform obtains write lock
 
813
            try:
 
814
                tt.new_symlink('foo', tt.root, 'bar')
 
815
                tt.apply()
 
816
            finally:
 
817
                wt.unlock()
818
818
        os_symlink = getattr(os, 'symlink', None)
819
819
        os.symlink = None
820
820
        try:
821
 
            tt_helper()
 
821
            err = self.assertRaises(errors.UnableCreateSymlink, tt_helper)
 
822
            self.assertEqual(
 
823
                "Unable to create symlink 'foo' on this platform",
 
824
                str(err))
822
825
        finally:
823
826
            if os_symlink:
824
827
                os.symlink = os_symlink
1147
1150
            self.assertEqual([(b'id-1', ('old', None), False, (True, False),
1148
1151
                               (b'eert_toor', b'eert_toor'),
1149
1152
                               ('old', 'old'), ('file', 'file'),
1150
 
                               (True, True), False)],
1151
 
                             list(transform.iter_changes()))
 
1153
                               (True, True))], list(transform.iter_changes()))
1152
1154
            transform.new_directory('new', root, b'id-1')
1153
1155
            self.assertEqual([(b'id-1', ('old', 'new'), True, (True, True),
1154
1156
                               (b'eert_toor', b'eert_toor'), ('old', 'new'),
1155
1157
                               ('file', 'directory'),
1156
 
                               (True, False), False)],
1157
 
                             list(transform.iter_changes()))
 
1158
                               (True, False))], list(transform.iter_changes()))
1158
1159
        finally:
1159
1160
            transform.finalize()
1160
1161
 
1170
1171
            self.assertEqual([(b'id-1', (None, 'old'), False, (False, True),
1171
1172
                               (b'eert_toor', b'eert_toor'),
1172
1173
                               ('old', 'old'), ('file', 'file'),
1173
 
                               (False, False), False)],
 
1174
                               (False, False))],
1174
1175
                             list(transform.iter_changes()))
1175
1176
        finally:
1176
1177
            transform.finalize()
1194
1195
            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1195
1196
                               (b'eert_toor', b'eert_toor'),
1196
1197
                               ('old', 'old'), ('file', None),
1197
 
                               (False, False), False)],
 
1198
                               (False, False))],
1198
1199
                             list(transform.iter_changes()))
1199
1200
 
1200
1201
            # content change
1202
1203
            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1203
1204
                               (b'eert_toor', b'eert_toor'),
1204
1205
                               ('old', 'old'), ('file', 'file'),
1205
 
                               (False, False), False)],
 
1206
                               (False, False))],
1206
1207
                             list(transform.iter_changes()))
1207
1208
            transform.cancel_deletion(old)
1208
1209
            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1209
1210
                               (b'eert_toor', b'eert_toor'),
1210
1211
                               ('old', 'old'), ('file', 'file'),
1211
 
                               (False, False), False)],
 
1212
                               (False, False))],
1212
1213
                             list(transform.iter_changes()))
1213
1214
            transform.cancel_creation(old)
1214
1215
 
1220
1221
            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1221
1222
                               (b'eert_toor', b'eert_toor'),
1222
1223
                               ('old', 'old'), ('file', 'file'),
1223
 
                               (False, False), False)],
 
1224
                               (False, False))],
1224
1225
                             list(transform.iter_changes()))
1225
1226
            transform.cancel_versioning(new)
1226
1227
            transform._removed_id = set()
1231
1232
            self.assertEqual([(b'id-1', ('old', 'old'), False, (True, True),
1232
1233
                               (b'eert_toor', b'eert_toor'),
1233
1234
                               ('old', 'old'), ('file', 'file'),
1234
 
                               (False, True), False)],
 
1235
                               (False, True))],
1235
1236
                             list(transform.iter_changes()))
1236
1237
            transform.set_executability(None, old)
1237
1238
 
1242
1243
            self.assertEqual([(b'id-1', ('old', 'new'), False, (True, True),
1243
1244
                               (b'eert_toor', b'eert_toor'),
1244
1245
                               ('old', 'new'), ('file', 'file'),
1245
 
                               (False, False), False)],
 
1246
                               (False, False))],
1246
1247
                             list(transform.iter_changes()))
1247
1248
            transform._new_name = {}
1248
1249
 
1253
1254
            self.assertEqual([(b'id-1', ('old', 'subdir/old'), False,
1254
1255
                               (True, True), (b'eert_toor',
1255
1256
                                              b'subdir-id'), ('old', 'old'),
1256
 
                               ('file', 'file'), (False, False), False)],
 
1257
                               ('file', 'file'), (False, False))],
1257
1258
                             list(transform.iter_changes()))
1258
1259
            transform._new_path = {}
1259
1260
 
1279
1280
            self.assertEqual(
1280
1281
                [(b'id-1', (u'file1', u'file1'), True, (True, True),
1281
1282
                 (b'eert_toor', b'eert_toor'), ('file1', u'file1'),
1282
 
                 ('file', None), (False, False), False),
 
1283
                 ('file', None), (False, False)),
1283
1284
                 (b'id-2', (u'file2', u'file2'), False, (True, True),
1284
1285
                 (b'eert_toor', b'eert_toor'), ('file2', u'file2'),
1285
 
                 ('file', 'file'), (False, True), False)],
 
1286
                 ('file', 'file'), (False, True))],
1286
1287
                list(transform.iter_changes()))
1287
1288
        finally:
1288
1289
            transform.finalize()
1305
1306
                               (True, True),
1306
1307
                               (b'toor_eert', b'toor_eert'),
1307
1308
                               ('floater', 'flitter'),
1308
 
                               (None, None), (False, False), False)],
 
1309
                               (None, None), (False, False))],
1309
1310
                             list(transform.iter_changes()))
1310
1311
        finally:
1311
1312
            transform.finalize()
1597
1598
        self.addCleanup(wt.unlock)
1598
1599
        self.assertEqual(wt.kind("foo"), "symlink")
1599
1600
 
1600
 
    def test_file_to_symlink_unsupported(self):
1601
 
        wt = self.make_branch_and_tree('.')
1602
 
        self.build_tree(['foo'])
1603
 
        wt.add(['foo'])
1604
 
        wt.commit("one")
1605
 
        self.overrideAttr(osutils, 'supports_symlinks', lambda p: False)
1606
 
        tt = TreeTransform(wt)
1607
 
        self.addCleanup(tt.finalize)
1608
 
        foo_trans_id = tt.trans_id_tree_path("foo")
1609
 
        tt.delete_contents(foo_trans_id)
1610
 
        log = BytesIO()
1611
 
        trace.push_log_file(log)
1612
 
        tt.create_symlink("bar", foo_trans_id)
1613
 
        tt.apply()
1614
 
        self.assertContainsRe(
1615
 
            log.getvalue(),
1616
 
            b'Unable to create symlink "foo" on this filesystem')
1617
 
 
1618
1601
    def test_dir_to_file(self):
1619
1602
        wt = self.make_branch_and_tree('.')
1620
1603
        self.build_tree(['foo/', 'foo/bar'])
1668
1651
        tree2 = self.make_branch_and_tree('tree2')
1669
1652
        tt = TreeTransform(tree2)
1670
1653
        foo_trans_id = tt.create_path('foo', tt.root)
1671
 
        create_from_tree(tt, foo_trans_id, tree1, 'foo')
 
1654
        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id=b'foo-id')
1672
1655
        bar_trans_id = tt.create_path('bar', tt.root)
1673
 
        create_from_tree(tt, bar_trans_id, tree1, 'bar')
 
1656
        create_from_tree(tt, bar_trans_id, tree1, 'bar', file_id=b'bar-id')
1674
1657
        tt.apply()
1675
1658
        self.assertEqual('directory', osutils.file_kind('tree2/foo'))
1676
1659
        self.assertFileEqual(b'baz', 'tree2/bar')
1683
1666
        tree2 = self.make_branch_and_tree('tree2')
1684
1667
        tt = TreeTransform(tree2)
1685
1668
        foo_trans_id = tt.create_path('foo', tt.root)
1686
 
        create_from_tree(tt, foo_trans_id, tree1, 'foo', chunks=[b'qux'])
 
1669
        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id=b'foo-id',
 
1670
                         chunks=[b'qux'])
1687
1671
        tt.apply()
1688
1672
        self.assertFileEqual(b'qux', 'tree2/foo')
1689
1673
 
1694
1678
        tree1.add('foo', b'foo-id')
1695
1679
        tt = TreeTransform(self.make_branch_and_tree('tree2'))
1696
1680
        foo_trans_id = tt.create_path('foo', tt.root)
1697
 
        create_from_tree(tt, foo_trans_id, tree1, 'foo')
 
1681
        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id=b'foo-id')
1698
1682
        tt.apply()
1699
1683
        self.assertEqual('bar', os.readlink('tree2/foo'))
1700
1684
 
1743
1727
        tree.add('foo', b'foo-id')
1744
1728
        with TransformPreview(tree) as tt:
1745
1729
            tt.unversion_file(tt.root)
1746
 
            tt.version_file(tree.path2id(''), tt.root)
 
1730
            tt.version_file(tree.get_root_id(), tt.root)
1747
1731
            tt.trans_id_tree_path('foo')
1748
1732
            self.assertEqual([], tt._inventory_altered())
1749
1733
 
1817
1801
        self.assertEqual(this.wt.get_file('i.OTHER').read(),
1818
1802
                         b'h\ni\nj\nk\n')
1819
1803
        self.assertEqual(os.path.exists(this.wt.abspath('i.BASE')), False)
1820
 
        modified = ['a', 'b', 'c', 'h', 'i']
 
1804
        modified = [b'a', b'b', b'c', b'h', b'i']
1821
1805
        merge_modified = this.wt.merge_modified()
1822
1806
        self.assertSubset(merge_modified, modified)
1823
1807
        self.assertEqual(len(merge_modified), len(modified))
2769
2753
 
2770
2754
A_ENTRY = (b'a-id', ('a', 'a'), True, (True, True),
2771
2755
           (b'TREE_ROOT', b'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
2772
 
           (False, False), False)
 
2756
           (False, False))
2773
2757
ROOT_ENTRY = (b'TREE_ROOT', ('', ''), False, (True, True), (None, None),
2774
 
              ('', ''), ('directory', 'directory'), (False, False), False)
 
2758
              ('', ''), ('directory', 'directory'), (False, False))
2775
2759
 
2776
2760
 
2777
2761
class TestTransformPreview(tests.TestCaseWithTransport):
2825
2809
        # 3 lines of diff administrivia
2826
2810
        self.assertEqual(lines[4], b"+content B")
2827
2811
 
2828
 
    def test_unsupported_symlink_diff(self):
2829
 
        self.requireFeature(SymlinkFeature)
2830
 
        tree = self.make_branch_and_tree('.')
2831
 
        self.build_tree_contents([('a', 'content 1')])
2832
 
        tree.set_root_id(b'TREE_ROOT')
2833
 
        tree.add('a', b'a-id')
2834
 
        os.symlink('a', 'foo')
2835
 
        tree.add('foo', b'foo-id')
2836
 
        tree.commit('rev1', rev_id=b'rev1')
2837
 
        revision_tree = tree.branch.repository.revision_tree(b'rev1')
2838
 
        preview = TransformPreview(revision_tree)
2839
 
        self.addCleanup(preview.finalize)
2840
 
        preview.delete_versioned(preview.trans_id_tree_path('foo'))
2841
 
        preview_tree = preview.get_preview_tree()
2842
 
        out = BytesIO()
2843
 
        log = BytesIO()
2844
 
        trace.push_log_file(log)
2845
 
        os_symlink = getattr(os, 'symlink', None)
2846
 
        os.symlink = None
2847
 
        try:
2848
 
            show_diff_trees(revision_tree, preview_tree, out)
2849
 
            lines = out.getvalue().splitlines()
2850
 
        finally:
2851
 
            os.symlink = os_symlink
2852
 
        self.assertContainsRe(
2853
 
            log.getvalue(),
2854
 
            b'Ignoring "foo" as symlinks are not supported on this filesystem')
2855
 
 
2856
2812
    def test_transform_conflicts(self):
2857
2813
        revision_tree = self.create_tree()
2858
2814
        preview = TransformPreview(revision_tree)
2874
2830
 
2875
2831
    def test_iter_changes(self):
2876
2832
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2877
 
        root = revision_tree.path2id('')
 
2833
        root = revision_tree.get_root_id()
2878
2834
        self.assertEqual([(b'a-id', ('a', 'a'), True, (True, True),
2879
2835
                           (root, root), ('a', 'a'), ('file', 'file'),
2880
 
                           (False, False), False)],
 
2836
                           (False, False))],
2881
2837
                         list(preview_tree.iter_changes(revision_tree)))
2882
2838
 
2883
2839
    def test_include_unchanged_succeeds(self):
2983
2939
        preview.unversion_file(c_trans_id)
2984
2940
        preview.version_file(b'c-id', c_trans_id)
2985
2941
        preview_tree = preview.get_preview_tree()
2986
 
        self.assertEqual({b'a-id', b'c-id', tree.path2id('')},
 
2942
        self.assertEqual({b'a-id', b'c-id', tree.get_root_id()},
2987
2943
                         preview_tree.all_file_ids())
2988
2944
 
2989
2945
    def test_path2id_deleted_unchanged(self):
3266
3222
            ('unchanged', b'd\n'),
3267
3223
            ('new-a', b'e\n'),
3268
3224
            ('new-b', b'f\n'),
3269
 
        ], list(tree_a.plan_file_merge('file', tree_b)))
 
3225
        ], list(tree_a.plan_file_merge(b'file-id', tree_b)))
3270
3226
 
3271
3227
    def test_plan_file_merge_revision_tree(self):
3272
3228
        work_a = self.make_branch_and_tree('wta')
3289
3245
            ('unchanged', b'd\n'),
3290
3246
            ('new-a', b'e\n'),
3291
3247
            ('new-b', b'f\n'),
3292
 
        ], list(tree_a.plan_file_merge('file', tree_b)))
 
3248
        ], list(tree_a.plan_file_merge(b'file-id', tree_b)))
3293
3249
 
3294
3250
    def test_walkdirs(self):
3295
3251
        preview = self.get_empty_preview()
3819
3775
        transform, root = self.get_transform()
3820
3776
        old_root_id = transform.tree_file_id(root)
3821
3777
        transform.apply()
3822
 
        self.assertEqual(old_root_id, self.wt.path2id(''))
 
3778
        self.assertEqual(old_root_id, self.wt.get_root_id())
3823
3779
        self.assertEqual([(self.wt, transform)], calls)
3824
3780
 
3825
3781
    def test_post_commit_hooks(self):
3832
3788
        transform, root = self.get_transform()
3833
3789
        old_root_id = transform.tree_file_id(root)
3834
3790
        transform.apply()
3835
 
        self.assertEqual(old_root_id, self.wt.path2id(''))
 
3791
        self.assertEqual(old_root_id, self.wt.get_root_id())
3836
3792
        self.assertEqual([(self.wt, transform)], calls)
3837
3793
 
3838
3794