← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_transform.py

  • Committer: Aaron Bentley
  • Date: 2007-12-25 04:17:50 UTC
  • mto: This revision was merged to the branch mainline in revision 3160.
  • Revision ID: aaron.bentley@utoronto.ca-20071225041750-t6chr3pmgnebvqcz
https://launchpad.net/bugs/177390
Handle non-directory parent conflicts (abentley, #177390)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
import os
18
18
import stat
19
 
from StringIO import StringIO
20
19
import sys
21
20
 
22
21
from bzrlib import (
23
22
    errors,
24
23
    generate_ids,
25
 
    osutils,
26
 
    progress,
27
 
    revision as _mod_revision,
28
24
    symbol_versioning,
29
25
    tests,
30
26
    urlutils,
33
29
from bzrlib.conflicts import (DuplicateEntry, DuplicateID, MissingParent,
34
30
                              UnversionedParent, ParentLoop, DeletingParent,
35
31
                              NonDirectoryParent)
36
 
from bzrlib.diff import show_diff_trees
37
32
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
38
33
                           ReusingTransform, CantMoveRoot, 
39
34
                           PathsNotVersionedError, ExistingLimbo,
43
38
from bzrlib.merge import Merge3Merger
44
39
from bzrlib.tests import (
45
40
    CaseInsensitiveFilesystemFeature,
46
 
    HardlinkFeature,
47
41
    SymlinkFeature,
48
42
    TestCase,
49
43
    TestCaseInTempDir,
51
45
    )
52
46
from bzrlib.transform import (TreeTransform, ROOT_PARENT, FinalPaths, 
53
47
                              resolve_conflicts, cook_conflicts, 
54
 
                              build_tree, get_backup_name,
55
 
                              _FileMover, resolve_checkout,
56
 
                              TransformPreview)
 
48
                              find_interesting, build_tree, get_backup_name,
 
49
                              change_entry, _FileMover, resolve_checkout)
 
50
 
57
51
 
58
52
class TestTreeTransform(tests.TestCaseWithTransport):
59
53
 
64
58
 
65
59
    def get_transform(self):
66
60
        transform = TreeTransform(self.wt)
67
 
        self.addCleanup(transform.finalize)
 
61
        #self.addCleanup(transform.finalize)
68
62
        return transform, transform.root
69
63
 
70
64
    def test_existing_limbo(self):
85
79
    def test_existing_pending_deletion(self):
86
80
        transform, root = self.get_transform()
87
81
        deletion_path = self._limbodir = urlutils.local_path_from_url(
88
 
            transform._tree._transport.abspath('pending-deletion'))
 
82
            transform._tree._control_files.controlfilename('pending-deletion'))
89
83
        os.mkdir(pathjoin(deletion_path, 'blocking-directory'))
90
84
        self.assertRaises(ImmortalPendingDeletion, transform.apply)
91
85
        self.assertRaises(LockError, self.wt.unlock)
135
129
        transform.finalize()
136
130
        transform.finalize()
137
131
 
138
 
    def test_hardlink(self):
139
 
        self.requireFeature(HardlinkFeature)
140
 
        transform, root = self.get_transform()
141
 
        transform.new_file('file1', root, 'contents')
142
 
        transform.apply()
143
 
        target = self.make_branch_and_tree('target')
144
 
        target_transform = TreeTransform(target)
145
 
        trans_id = target_transform.create_path('file1', target_transform.root)
146
 
        target_transform.create_hardlink(self.wt.abspath('file1'), trans_id)
147
 
        target_transform.apply()
148
 
        self.failUnlessExists('target/file1')
149
 
        source_stat = os.stat(self.wt.abspath('file1'))
150
 
        target_stat = os.stat('target/file1')
151
 
        self.assertEqual(source_stat, target_stat)
152
 
 
153
132
    def test_convenience(self):
154
133
        transform, root = self.get_transform()
155
134
        self.wt.lock_tree_write()
272
251
        transform.new_file('FiLe', transform.root, 'content')
273
252
        result = transform.find_conflicts()
274
253
        self.assertEqual([], result)
275
 
        transform.finalize()
276
254
        # Force the tree to report that it is case insensitive, for conflict
277
255
        # generation tests
278
256
        tree.case_sensitive = False
279
 
        transform = TreeTransform(tree)
280
 
        self.addCleanup(transform.finalize)
281
 
        transform.new_file('file', transform.root, 'content')
282
 
        transform.new_file('FiLe', transform.root, 'content')
283
257
        result = transform.find_conflicts()
284
258
        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
285
259
 
295
269
        transform.new_file('file', transform.root, 'content')
296
270
        result = transform.find_conflicts()
297
271
        self.assertEqual([], result)
298
 
        transform.finalize()
299
272
        # Force the tree to report that it is case insensitive, for conflict
300
273
        # generation tests
301
274
        tree.case_sensitive = False
302
 
        transform = TreeTransform(tree)
303
 
        self.addCleanup(transform.finalize)
304
 
        transform.new_file('file', transform.root, 'content')
305
275
        result = transform.find_conflicts()
306
276
        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
307
277
 
747
717
        rename.set_executability(True, myfile)
748
718
        rename.apply()
749
719
 
 
720
    def test_find_interesting(self):
 
721
        create, root = self.get_transform()
 
722
        wt = create._tree
 
723
        create.new_file('vfile', root, 'myfile-text', 'myfile-id')
 
724
        create.new_file('uvfile', root, 'othertext')
 
725
        create.apply()
 
726
        result = self.applyDeprecated(symbol_versioning.zero_fifteen,
 
727
            find_interesting, wt, wt, ['vfile'])
 
728
        self.assertEqual(result, set(['myfile-id']))
 
729
 
750
730
    def test_set_executability_order(self):
751
731
        """Ensure that executability behaves the same, no matter what order.
752
732
        
779
759
        transform, root = self.get_transform()
780
760
        transform.new_file('file1', root, 'contents', 'file1-id', True)
781
761
        transform.apply()
782
 
        self.wt.lock_write()
783
 
        self.addCleanup(self.wt.unlock)
784
762
        self.assertTrue(self.wt.is_executable('file1-id'))
785
763
        transform, root = self.get_transform()
786
764
        file1_id = transform.trans_id_tree_file_id('file1-id')
826
804
        transform.apply()
827
805
        transform, root = self.get_transform()
828
806
        try:
829
 
            self.assertEqual([], list(transform.iter_changes()))
 
807
            self.assertEqual([], list(transform._iter_changes()))
830
808
            old = transform.trans_id_tree_file_id('id-1')
831
809
            transform.unversion_file(old)
832
810
            self.assertEqual([('id-1', ('old', None), False, (True, False),
833
811
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
834
 
                (True, True))], list(transform.iter_changes()))
 
812
                (True, True))], list(transform._iter_changes()))
835
813
            transform.new_directory('new', root, 'id-1')
836
814
            self.assertEqual([('id-1', ('old', 'new'), True, (True, True),
837
815
                ('eert_toor', 'eert_toor'), ('old', 'new'),
838
816
                ('file', 'directory'),
839
 
                (True, False))], list(transform.iter_changes()))
 
817
                (True, False))], list(transform._iter_changes()))
840
818
        finally:
841
819
            transform.finalize()
842
820
 
851
829
            transform.version_file('id-1', old)
852
830
            self.assertEqual([('id-1', (None, 'old'), False, (False, True),
853
831
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
854
 
                (False, False))], list(transform.iter_changes()))
 
832
                (False, False))], list(transform._iter_changes()))
855
833
        finally:
856
834
            transform.finalize()
857
835
 
867
845
            old = transform.trans_id_tree_path('old')
868
846
            subdir = transform.trans_id_tree_file_id('subdir-id')
869
847
            new = transform.trans_id_tree_path('new')
870
 
            self.assertEqual([], list(transform.iter_changes()))
 
848
            self.assertEqual([], list(transform._iter_changes()))
871
849
 
872
850
            #content deletion
873
851
            transform.delete_contents(old)
874
852
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
875
853
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', None),
876
 
                (False, False))], list(transform.iter_changes()))
 
854
                (False, False))], list(transform._iter_changes()))
877
855
 
878
856
            #content change
879
857
            transform.create_file('blah', old)
880
858
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
881
859
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
882
 
                (False, False))], list(transform.iter_changes()))
 
860
                (False, False))], list(transform._iter_changes()))
883
861
            transform.cancel_deletion(old)
884
862
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
885
863
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
886
 
                (False, False))], list(transform.iter_changes()))
 
864
                (False, False))], list(transform._iter_changes()))
887
865
            transform.cancel_creation(old)
888
866
 
889
867
            # move file_id to a different file
890
 
            self.assertEqual([], list(transform.iter_changes()))
 
868
            self.assertEqual([], list(transform._iter_changes()))
891
869
            transform.unversion_file(old)
892
870
            transform.version_file('id-1', new)
893
871
            transform.adjust_path('old', root, new)
894
872
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
895
873
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
896
 
                (False, False))], list(transform.iter_changes()))
 
874
                (False, False))], list(transform._iter_changes()))
897
875
            transform.cancel_versioning(new)
898
876
            transform._removed_id = set()
899
877
 
900
878
            #execute bit
901
 
            self.assertEqual([], list(transform.iter_changes()))
 
879
            self.assertEqual([], list(transform._iter_changes()))
902
880
            transform.set_executability(True, old)
903
881
            self.assertEqual([('id-1', ('old', 'old'), False, (True, True),
904
882
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
905
 
                (False, True))], list(transform.iter_changes()))
 
883
                (False, True))], list(transform._iter_changes()))
906
884
            transform.set_executability(None, old)
907
885
 
908
886
            # filename
909
 
            self.assertEqual([], list(transform.iter_changes()))
 
887
            self.assertEqual([], list(transform._iter_changes()))
910
888
            transform.adjust_path('new', root, old)
911
889
            transform._new_parent = {}
912
890
            self.assertEqual([('id-1', ('old', 'new'), False, (True, True),
913
891
                ('eert_toor', 'eert_toor'), ('old', 'new'), ('file', 'file'),
914
 
                (False, False))], list(transform.iter_changes()))
 
892
                (False, False))], list(transform._iter_changes()))
915
893
            transform._new_name = {}
916
894
 
917
895
            # parent directory
918
 
            self.assertEqual([], list(transform.iter_changes()))
 
896
            self.assertEqual([], list(transform._iter_changes()))
919
897
            transform.adjust_path('new', subdir, old)
920
898
            transform._new_name = {}
921
899
            self.assertEqual([('id-1', ('old', 'subdir/old'), False,
922
900
                (True, True), ('eert_toor', 'subdir-id'), ('old', 'old'),
923
901
                ('file', 'file'), (False, False))],
924
 
                list(transform.iter_changes()))
 
902
                list(transform._iter_changes()))
925
903
            transform._new_path = {}
926
904
 
927
905
        finally:
949
927
                ('id-2', (u'file2', u'file2'), False, (True, True),
950
928
                ('eert_toor', 'eert_toor'), ('file2', u'file2'),
951
929
                ('file', 'file'), (False, True))],
952
 
                list(transform.iter_changes()))
 
930
                list(transform._iter_changes()))
953
931
        finally:
954
932
            transform.finalize()
955
933
 
969
947
            transform.adjust_path('flitter', root, floater)
970
948
            self.assertEqual([('floater-id', ('floater', 'flitter'), False,
971
949
            (True, True), ('toor_eert', 'toor_eert'), ('floater', 'flitter'),
972
 
            (None, None), (False, False))], list(transform.iter_changes()))
 
950
            (None, None), (False, False))], list(transform._iter_changes()))
973
951
        finally:
974
952
            transform.finalize()
975
953
 
984
962
        try:
985
963
            old = transform.trans_id_tree_path('old')
986
964
            subdir = transform.trans_id_tree_file_id('subdir-id')
987
 
            self.assertEqual([], list(transform.iter_changes()))
 
965
            self.assertEqual([], list(transform._iter_changes()))
988
966
            transform.delete_contents(subdir)
989
967
            transform.create_directory(subdir)
990
968
            transform.set_executability(False, old)
991
969
            transform.unversion_file(old)
992
970
            transform.version_file('id-1', old)
993
971
            transform.adjust_path('old', root, old)
994
 
            self.assertEqual([], list(transform.iter_changes()))
 
972
            self.assertEqual([], list(transform._iter_changes()))
995
973
        finally:
996
974
            transform.finalize()
997
975
 
1162
1140
        transform.cancel_creation(parent)
1163
1141
        transform.finalize()
1164
1142
 
 
1143
    def test_change_entry(self):
 
1144
        txt = 'bzrlib.transform.change_entry was deprecated in version 0.90.'
 
1145
        self.callDeprecated([txt], change_entry, None, None, None, None, None,
 
1146
            None, None, None)
 
1147
 
1165
1148
    def test_case_insensitive_clash(self):
1166
1149
        self.requireFeature(CaseInsensitiveFilesystemFeature)
1167
1150
        def tt_helper():
1215
1198
        self.assertContainsRe(str(err),
1216
1199
            "^File exists: .+/foo")
1217
1200
 
1218
 
    def test_file_to_directory(self):
1219
 
        wt = self.make_branch_and_tree('.')
1220
 
        self.build_tree(['foo'])
1221
 
        wt.add(['foo'])
1222
 
        wt.commit("one")
1223
 
        tt = TreeTransform(wt)
1224
 
        self.addCleanup(tt.finalize)
1225
 
        foo_trans_id = tt.trans_id_tree_path("foo")
1226
 
        tt.delete_contents(foo_trans_id)
1227
 
        tt.create_directory(foo_trans_id)
1228
 
        bar_trans_id = tt.trans_id_tree_path("foo/bar")
1229
 
        tt.create_file(["aa\n"], bar_trans_id)
1230
 
        tt.version_file("bar-1", bar_trans_id)
1231
 
        tt.apply()
1232
 
        self.failUnlessExists("foo/bar")
1233
 
        wt.lock_read()
1234
 
        try:
1235
 
            self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1236
 
                    "directory")
1237
 
        finally:
1238
 
            wt.unlock()
1239
 
        wt.commit("two")
1240
 
        changes = wt.changes_from(wt.basis_tree())
1241
 
        self.assertFalse(changes.has_changed(), changes)
1242
 
 
1243
 
    def test_file_to_symlink(self):
1244
 
        self.requireFeature(SymlinkFeature)
1245
 
        wt = self.make_branch_and_tree('.')
1246
 
        self.build_tree(['foo'])
1247
 
        wt.add(['foo'])
1248
 
        wt.commit("one")
1249
 
        tt = TreeTransform(wt)
1250
 
        self.addCleanup(tt.finalize)
1251
 
        foo_trans_id = tt.trans_id_tree_path("foo")
1252
 
        tt.delete_contents(foo_trans_id)
1253
 
        tt.create_symlink("bar", foo_trans_id)
1254
 
        tt.apply()
1255
 
        self.failUnlessExists("foo")
1256
 
        wt.lock_read()
1257
 
        self.addCleanup(wt.unlock)
1258
 
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1259
 
                "symlink")
1260
 
 
1261
 
    def test_dir_to_file(self):
1262
 
        wt = self.make_branch_and_tree('.')
1263
 
        self.build_tree(['foo/', 'foo/bar'])
1264
 
        wt.add(['foo', 'foo/bar'])
1265
 
        wt.commit("one")
1266
 
        tt = TreeTransform(wt)
1267
 
        self.addCleanup(tt.finalize)
1268
 
        foo_trans_id = tt.trans_id_tree_path("foo")
1269
 
        bar_trans_id = tt.trans_id_tree_path("foo/bar")
1270
 
        tt.delete_contents(foo_trans_id)
1271
 
        tt.delete_versioned(bar_trans_id)
1272
 
        tt.create_file(["aa\n"], foo_trans_id)
1273
 
        tt.apply()
1274
 
        self.failUnlessExists("foo")
1275
 
        wt.lock_read()
1276
 
        self.addCleanup(wt.unlock)
1277
 
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1278
 
                "file")
1279
 
 
1280
 
    def test_dir_to_hardlink(self):
1281
 
        self.requireFeature(HardlinkFeature)
1282
 
        wt = self.make_branch_and_tree('.')
1283
 
        self.build_tree(['foo/', 'foo/bar'])
1284
 
        wt.add(['foo', 'foo/bar'])
1285
 
        wt.commit("one")
1286
 
        tt = TreeTransform(wt)
1287
 
        self.addCleanup(tt.finalize)
1288
 
        foo_trans_id = tt.trans_id_tree_path("foo")
1289
 
        bar_trans_id = tt.trans_id_tree_path("foo/bar")
1290
 
        tt.delete_contents(foo_trans_id)
1291
 
        tt.delete_versioned(bar_trans_id)
1292
 
        self.build_tree(['baz'])
1293
 
        tt.create_hardlink("baz", foo_trans_id)
1294
 
        tt.apply()
1295
 
        self.failUnlessExists("foo")
1296
 
        self.failUnlessExists("baz")
1297
 
        wt.lock_read()
1298
 
        self.addCleanup(wt.unlock)
1299
 
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1300
 
                "file")
1301
 
 
1302
 
    def test_no_final_path(self):
1303
 
        transform, root = self.get_transform()
1304
 
        trans_id = transform.trans_id_file_id('foo')
1305
 
        transform.create_file('bar', trans_id)
1306
 
        transform.cancel_creation(trans_id)
1307
 
        transform.apply()
1308
 
 
1309
1201
 
1310
1202
class TransformGroup(object):
1311
1203
 
1325
1217
 
1326
1218
 
1327
1219
class TestTransformMerge(TestCaseInTempDir):
1328
 
 
1329
1220
    def test_text_merge(self):
1330
1221
        root_id = generate_ids.gen_root_id()
1331
1222
        base = TransformGroup("base", root_id)
1361
1252
        this.tt.new_file('i', this.root, '1\n2\n3\n4\n', 'i')
1362
1253
        this.tt.apply()
1363
1254
        Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1364
 
 
1365
1255
        # textual merge
1366
1256
        self.assertEqual(this.wt.get_file('a').read(), 'y\nb\nc\nd\bz\n')
1367
1257
        # three-way text conflict
1665
1555
        # children of non-root directories should not be renamed
1666
1556
        self.assertEqual(2, transform_result.rename_count)
1667
1557
 
1668
 
    def create_ab_tree(self):
1669
 
        """Create a committed test tree with two files"""
1670
 
        source = self.make_branch_and_tree('source')
1671
 
        self.build_tree_contents([('source/file1', 'A')])
1672
 
        self.build_tree_contents([('source/file2', 'B')])
1673
 
        source.add(['file1', 'file2'], ['file1-id', 'file2-id'])
1674
 
        source.commit('commit files')
1675
 
        source.lock_write()
1676
 
        self.addCleanup(source.unlock)
1677
 
        return source
1678
 
 
1679
1558
    def test_build_tree_accelerator_tree(self):
1680
 
        source = self.create_ab_tree()
 
1559
        source = self.make_branch_and_tree('source')
 
1560
        self.build_tree_contents([('source/file1', 'A')])
 
1561
        self.build_tree_contents([('source/file2', 'B')])
 
1562
        source.add(['file1', 'file2'], ['file1-id', 'file2-id'])
 
1563
        source.commit('commit files')
1681
1564
        self.build_tree_contents([('source/file2', 'C')])
1682
1565
        calls = []
1683
1566
        real_source_get_file = source.get_file
1685
1568
            calls.append(file_id)
1686
1569
            return real_source_get_file(file_id, path)
1687
1570
        source.get_file = get_file
 
1571
        source.lock_read()
 
1572
        self.addCleanup(source.unlock)
1688
1573
        target = self.make_branch_and_tree('target')
1689
1574
        revision_tree = source.basis_tree()
1690
1575
        revision_tree.lock_read()
1693
1578
        self.assertEqual(['file1-id'], calls)
1694
1579
        target.lock_read()
1695
1580
        self.addCleanup(target.unlock)
1696
 
        self.assertEqual([], list(target.iter_changes(revision_tree)))
 
1581
        self.assertEqual([], list(target._iter_changes(revision_tree)))
1697
1582
 
1698
1583
    def test_build_tree_accelerator_tree_missing_file(self):
1699
 
        source = self.create_ab_tree()
 
1584
        source = self.make_branch_and_tree('source')
 
1585
        self.build_tree_contents([('source/file1', 'A')])
 
1586
        self.build_tree_contents([('source/file2', 'B')])
 
1587
        source.add(['file1', 'file2'])
 
1588
        source.commit('commit files')
1700
1589
        os.unlink('source/file1')
1701
1590
        source.remove(['file2'])
1702
1591
        target = self.make_branch_and_tree('target')
1706
1595
        build_tree(revision_tree, target, source)
1707
1596
        target.lock_read()
1708
1597
        self.addCleanup(target.unlock)
1709
 
        self.assertEqual([], list(target.iter_changes(revision_tree)))
 
1598
        self.assertEqual([], list(target._iter_changes(revision_tree)))
1710
1599
 
1711
1600
    def test_build_tree_accelerator_wrong_kind(self):
1712
 
        self.requireFeature(SymlinkFeature)
1713
1601
        source = self.make_branch_and_tree('source')
1714
1602
        self.build_tree_contents([('source/file1', '')])
1715
1603
        self.build_tree_contents([('source/file2', '')])
1725
1613
            calls.append(file_id)
1726
1614
            return real_source_get_file(file_id, path)
1727
1615
        source.get_file = get_file
 
1616
        source.lock_read()
 
1617
        self.addCleanup(source.unlock)
1728
1618
        target = self.make_branch_and_tree('target')
1729
1619
        revision_tree = source.basis_tree()
1730
1620
        revision_tree.lock_read()
1733
1623
        self.assertEqual([], calls)
1734
1624
        target.lock_read()
1735
1625
        self.addCleanup(target.unlock)
1736
 
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1737
 
 
1738
 
    def test_build_tree_hardlink(self):
1739
 
        self.requireFeature(HardlinkFeature)
1740
 
        source = self.create_ab_tree()
1741
 
        target = self.make_branch_and_tree('target')
1742
 
        revision_tree = source.basis_tree()
1743
 
        revision_tree.lock_read()
1744
 
        self.addCleanup(revision_tree.unlock)
1745
 
        build_tree(revision_tree, target, source, hardlink=True)
1746
 
        target.lock_read()
1747
 
        self.addCleanup(target.unlock)
1748
 
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1749
 
        source_stat = os.stat('source/file1')
1750
 
        target_stat = os.stat('target/file1')
1751
 
        self.assertEqual(source_stat, target_stat)
1752
 
 
1753
 
        # Explicitly disallowing hardlinks should prevent them.
1754
 
        target2 = self.make_branch_and_tree('target2')
1755
 
        build_tree(revision_tree, target2, source, hardlink=False)
1756
 
        target2.lock_read()
1757
 
        self.addCleanup(target2.unlock)
1758
 
        self.assertEqual([], list(target2.iter_changes(revision_tree)))
1759
 
        source_stat = os.stat('source/file1')
1760
 
        target2_stat = os.stat('target2/file1')
1761
 
        self.assertNotEqual(source_stat, target2_stat)
 
1626
        self.assertEqual([], list(target._iter_changes(revision_tree)))
1762
1627
 
1763
1628
    def test_build_tree_accelerator_tree_moved(self):
1764
1629
        source = self.make_branch_and_tree('source')
1775
1640
        build_tree(revision_tree, target, source)
1776
1641
        target.lock_read()
1777
1642
        self.addCleanup(target.unlock)
1778
 
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1779
 
 
1780
 
    def test_build_tree_hardlinks_preserve_execute(self):
1781
 
        self.requireFeature(HardlinkFeature)
1782
 
        source = self.create_ab_tree()
1783
 
        tt = TreeTransform(source)
1784
 
        trans_id = tt.trans_id_tree_file_id('file1-id')
1785
 
        tt.set_executability(True, trans_id)
1786
 
        tt.apply()
1787
 
        self.assertTrue(source.is_executable('file1-id'))
1788
 
        target = self.make_branch_and_tree('target')
1789
 
        revision_tree = source.basis_tree()
1790
 
        revision_tree.lock_read()
1791
 
        self.addCleanup(revision_tree.unlock)
1792
 
        build_tree(revision_tree, target, source, hardlink=True)
1793
 
        target.lock_read()
1794
 
        self.addCleanup(target.unlock)
1795
 
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1796
 
        self.assertTrue(source.is_executable('file1-id'))
1797
 
 
1798
 
    def test_case_insensitive_build_tree_inventory(self):
1799
 
        source = self.make_branch_and_tree('source')
1800
 
        self.build_tree(['source/file', 'source/FILE'])
1801
 
        source.add(['file', 'FILE'], ['lower-id', 'upper-id'])
1802
 
        source.commit('added files')
1803
 
        # Don't try this at home, kids!
1804
 
        # Force the tree to report that it is case insensitive
1805
 
        target = self.make_branch_and_tree('target')
1806
 
        target.case_sensitive = False
1807
 
        build_tree(source.basis_tree(), target, source, delta_from_tree=True)
1808
 
        self.assertEqual('file.moved', target.id2path('lower-id'))
1809
 
        self.assertEqual('FILE', target.id2path('upper-id'))
 
1643
        self.assertEqual([], list(target._iter_changes(revision_tree)))
1810
1644
 
1811
1645
 
1812
1646
class MockTransform(object):
1967
1801
        parent = tt.trans_id_file_id('parent-id')
1968
1802
        tt.new_file('file', parent, 'Contents')
1969
1803
        resolve_conflicts(tt)
1970
 
 
1971
 
 
1972
 
class TestTransformPreview(tests.TestCaseWithTransport):
1973
 
 
1974
 
    def create_tree(self):
1975
 
        tree = self.make_branch_and_tree('.')
1976
 
        self.build_tree_contents([('a', 'content 1')])
1977
 
        tree.add('a', 'a-id')
1978
 
        tree.commit('rev1', rev_id='rev1')
1979
 
        return tree.branch.repository.revision_tree('rev1')
1980
 
 
1981
 
    def get_empty_preview(self):
1982
 
        repository = self.make_repository('repo')
1983
 
        tree = repository.revision_tree(_mod_revision.NULL_REVISION)
1984
 
        preview = TransformPreview(tree)
1985
 
        self.addCleanup(preview.finalize)
1986
 
        return preview
1987
 
 
1988
 
    def test_transform_preview(self):
1989
 
        revision_tree = self.create_tree()
1990
 
        preview = TransformPreview(revision_tree)
1991
 
        self.addCleanup(preview.finalize)
1992
 
 
1993
 
    def test_transform_preview_tree(self):
1994
 
        revision_tree = self.create_tree()
1995
 
        preview = TransformPreview(revision_tree)
1996
 
        self.addCleanup(preview.finalize)
1997
 
        preview.get_preview_tree()
1998
 
 
1999
 
    def test_transform_new_file(self):
2000
 
        revision_tree = self.create_tree()
2001
 
        preview = TransformPreview(revision_tree)
2002
 
        self.addCleanup(preview.finalize)
2003
 
        preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
2004
 
        preview_tree = preview.get_preview_tree()
2005
 
        self.assertEqual(preview_tree.kind('file2-id'), 'file')
2006
 
        self.assertEqual(
2007
 
            preview_tree.get_file('file2-id').read(), 'content B\n')
2008
 
 
2009
 
    def test_diff_preview_tree(self):
2010
 
        revision_tree = self.create_tree()
2011
 
        preview = TransformPreview(revision_tree)
2012
 
        self.addCleanup(preview.finalize)
2013
 
        preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
2014
 
        preview_tree = preview.get_preview_tree()
2015
 
        out = StringIO()
2016
 
        show_diff_trees(revision_tree, preview_tree, out)
2017
 
        lines = out.getvalue().splitlines()
2018
 
        self.assertEqual(lines[0], "=== added file 'file2'")
2019
 
        # 3 lines of diff administrivia
2020
 
        self.assertEqual(lines[4], "+content B")
2021
 
 
2022
 
    def test_transform_conflicts(self):
2023
 
        revision_tree = self.create_tree()
2024
 
        preview = TransformPreview(revision_tree)
2025
 
        self.addCleanup(preview.finalize)
2026
 
        preview.new_file('a', preview.root, 'content 2')
2027
 
        resolve_conflicts(preview)
2028
 
        trans_id = preview.trans_id_file_id('a-id')
2029
 
        self.assertEqual('a.moved', preview.final_name(trans_id))
2030
 
 
2031
 
    def get_tree_and_preview_tree(self):
2032
 
        revision_tree = self.create_tree()
2033
 
        preview = TransformPreview(revision_tree)
2034
 
        self.addCleanup(preview.finalize)
2035
 
        a_trans_id = preview.trans_id_file_id('a-id')
2036
 
        preview.delete_contents(a_trans_id)
2037
 
        preview.create_file('b content', a_trans_id)
2038
 
        preview_tree = preview.get_preview_tree()
2039
 
        return revision_tree, preview_tree
2040
 
 
2041
 
    def test_iter_changes(self):
2042
 
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2043
 
        root = revision_tree.inventory.root.file_id
2044
 
        self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
2045
 
                          (root, root), ('a', 'a'), ('file', 'file'),
2046
 
                          (False, False))],
2047
 
                          list(preview_tree.iter_changes(revision_tree)))
2048
 
 
2049
 
    def test_wrong_tree_value_error(self):
2050
 
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2051
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
2052
 
                              preview_tree)
2053
 
        self.assertEqual('from_tree must be transform source tree.', str(e))
2054
 
 
2055
 
    def test_include_unchanged_value_error(self):
2056
 
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2057
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
2058
 
                              revision_tree, include_unchanged=True)
2059
 
        self.assertEqual('include_unchanged is not supported', str(e))
2060
 
 
2061
 
    def test_specific_files(self):
2062
 
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2063
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
2064
 
                              revision_tree, specific_files=['pete'])
2065
 
        self.assertEqual('specific_files is not supported', str(e))
2066
 
 
2067
 
    def test_want_unversioned_value_error(self):
2068
 
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2069
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
2070
 
                              revision_tree, want_unversioned=True)
2071
 
        self.assertEqual('want_unversioned is not supported', str(e))
2072
 
 
2073
 
    def test_ignore_extra_trees_no_specific_files(self):
2074
 
        # extra_trees is harmless without specific_files, so we'll silently
2075
 
        # accept it, even though we won't use it.
2076
 
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2077
 
        preview_tree.iter_changes(revision_tree, extra_trees=[preview_tree])
2078
 
 
2079
 
    def test_ignore_require_versioned_no_specific_files(self):
2080
 
        # require_versioned is meaningless without specific_files.
2081
 
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2082
 
        preview_tree.iter_changes(revision_tree, require_versioned=False)
2083
 
 
2084
 
    def test_ignore_pb(self):
2085
 
        # pb could be supported, but TT.iter_changes doesn't support it.
2086
 
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2087
 
        preview_tree.iter_changes(revision_tree, pb=progress.DummyProgress())
2088
 
 
2089
 
    def test_kind(self):
2090
 
        revision_tree = self.create_tree()
2091
 
        preview = TransformPreview(revision_tree)
2092
 
        self.addCleanup(preview.finalize)
2093
 
        preview.new_file('file', preview.root, 'contents', 'file-id')
2094
 
        preview.new_directory('directory', preview.root, 'dir-id')
2095
 
        preview_tree = preview.get_preview_tree()
2096
 
        self.assertEqual('file', preview_tree.kind('file-id'))
2097
 
        self.assertEqual('directory', preview_tree.kind('dir-id'))
2098
 
 
2099
 
    def test_get_file_mtime(self):
2100
 
        preview = self.get_empty_preview()
2101
 
        file_trans_id = preview.new_file('file', preview.root, 'contents',
2102
 
                                         'file-id')
2103
 
        limbo_path = preview._limbo_name(file_trans_id)
2104
 
        preview_tree = preview.get_preview_tree()
2105
 
        self.assertEqual(os.stat(limbo_path).st_mtime,
2106
 
                         preview_tree.get_file_mtime('file-id'))
2107
 
 
2108
 
    def test_get_file(self):
2109
 
        preview = self.get_empty_preview()
2110
 
        preview.new_file('file', preview.root, 'contents', 'file-id')
2111
 
        preview_tree = preview.get_preview_tree()
2112
 
        tree_file = preview_tree.get_file('file-id')
2113
 
        try:
2114
 
            self.assertEqual('contents', tree_file.read())
2115
 
        finally:
2116
 
            tree_file.close()
2117
 
 
2118
 
    def test_get_symlink_target(self):
2119
 
        self.requireFeature(SymlinkFeature)
2120
 
        preview = self.get_empty_preview()
2121
 
        preview.new_symlink('symlink', preview.root, 'target', 'symlink-id')
2122
 
        preview_tree = preview.get_preview_tree()
2123
 
        self.assertEqual('target',
2124
 
                         preview_tree.get_symlink_target('symlink-id'))
2125
 
 
2126
 
    def test_all_file_ids(self):
2127
 
        tree = self.make_branch_and_tree('tree')
2128
 
        self.build_tree(['tree/a', 'tree/b', 'tree/c'])
2129
 
        tree.add(['a', 'b', 'c'], ['a-id', 'b-id', 'c-id'])
2130
 
        preview = TransformPreview(tree)
2131
 
        self.addCleanup(preview.finalize)
2132
 
        preview.unversion_file(preview.trans_id_file_id('b-id'))
2133
 
        c_trans_id = preview.trans_id_file_id('c-id')
2134
 
        preview.unversion_file(c_trans_id)
2135
 
        preview.version_file('c-id', c_trans_id)
2136
 
        preview_tree = preview.get_preview_tree()
2137
 
        self.assertEqual(set(['a-id', 'c-id', tree.get_root_id()]),
2138
 
                         preview_tree.all_file_ids())
2139
 
 
2140
 
    def test_path2id_deleted_unchanged(self):
2141
 
        tree = self.make_branch_and_tree('tree')
2142
 
        self.build_tree(['tree/unchanged', 'tree/deleted'])
2143
 
        tree.add(['unchanged', 'deleted'], ['unchanged-id', 'deleted-id'])
2144
 
        preview = TransformPreview(tree)
2145
 
        self.addCleanup(preview.finalize)
2146
 
        preview.unversion_file(preview.trans_id_file_id('deleted-id'))
2147
 
        preview_tree = preview.get_preview_tree()
2148
 
        self.assertEqual('unchanged-id', preview_tree.path2id('unchanged'))
2149
 
        self.assertIs(None, preview_tree.path2id('deleted'))
2150
 
 
2151
 
    def test_path2id_created(self):
2152
 
        tree = self.make_branch_and_tree('tree')
2153
 
        self.build_tree(['tree/unchanged'])
2154
 
        tree.add(['unchanged'], ['unchanged-id'])
2155
 
        preview = TransformPreview(tree)
2156
 
        self.addCleanup(preview.finalize)
2157
 
        preview.new_file('new', preview.trans_id_file_id('unchanged-id'),
2158
 
            'contents', 'new-id')
2159
 
        preview_tree = preview.get_preview_tree()
2160
 
        self.assertEqual('new-id', preview_tree.path2id('unchanged/new'))
2161
 
 
2162
 
    def test_path2id_moved(self):
2163
 
        tree = self.make_branch_and_tree('tree')
2164
 
        self.build_tree(['tree/old_parent/', 'tree/old_parent/child'])
2165
 
        tree.add(['old_parent', 'old_parent/child'],
2166
 
                 ['old_parent-id', 'child-id'])
2167
 
        preview = TransformPreview(tree)
2168
 
        self.addCleanup(preview.finalize)
2169
 
        new_parent = preview.new_directory('new_parent', preview.root,
2170
 
                                           'new_parent-id')
2171
 
        preview.adjust_path('child', new_parent,
2172
 
                            preview.trans_id_file_id('child-id'))
2173
 
        preview_tree = preview.get_preview_tree()
2174
 
        self.assertIs(None, preview_tree.path2id('old_parent/child'))
2175
 
        self.assertEqual('child-id', preview_tree.path2id('new_parent/child'))
2176
 
 
2177
 
    def test_path2id_renamed_parent(self):
2178
 
        tree = self.make_branch_and_tree('tree')
2179
 
        self.build_tree(['tree/old_name/', 'tree/old_name/child'])
2180
 
        tree.add(['old_name', 'old_name/child'],
2181
 
                 ['parent-id', 'child-id'])
2182
 
        preview = TransformPreview(tree)
2183
 
        self.addCleanup(preview.finalize)
2184
 
        preview.adjust_path('new_name', preview.root,
2185
 
                            preview.trans_id_file_id('parent-id'))
2186
 
        preview_tree = preview.get_preview_tree()
2187
 
        self.assertIs(None, preview_tree.path2id('old_name/child'))
2188
 
        self.assertEqual('child-id', preview_tree.path2id('new_name/child'))
2189
 
 
2190
 
    def assertMatchingIterEntries(self, tt, specific_file_ids=None):
2191
 
        preview_tree = tt.get_preview_tree()
2192
 
        preview_result = list(preview_tree.iter_entries_by_dir(
2193
 
                              specific_file_ids))
2194
 
        tree = tt._tree
2195
 
        tt.apply()
2196
 
        actual_result = list(tree.iter_entries_by_dir(specific_file_ids))
2197
 
        self.assertEqual(actual_result, preview_result)
2198
 
 
2199
 
    def test_iter_entries_by_dir_new(self):
2200
 
        tree = self.make_branch_and_tree('tree')
2201
 
        tt = TreeTransform(tree)
2202
 
        tt.new_file('new', tt.root, 'contents', 'new-id')
2203
 
        self.assertMatchingIterEntries(tt)
2204
 
 
2205
 
    def test_iter_entries_by_dir_deleted(self):
2206
 
        tree = self.make_branch_and_tree('tree')
2207
 
        self.build_tree(['tree/deleted'])
2208
 
        tree.add('deleted', 'deleted-id')
2209
 
        tt = TreeTransform(tree)
2210
 
        tt.delete_contents(tt.trans_id_file_id('deleted-id'))
2211
 
        self.assertMatchingIterEntries(tt)
2212
 
 
2213
 
    def test_iter_entries_by_dir_unversioned(self):
2214
 
        tree = self.make_branch_and_tree('tree')
2215
 
        self.build_tree(['tree/removed'])
2216
 
        tree.add('removed', 'removed-id')
2217
 
        tt = TreeTransform(tree)
2218
 
        tt.unversion_file(tt.trans_id_file_id('removed-id'))
2219
 
        self.assertMatchingIterEntries(tt)
2220
 
 
2221
 
    def test_iter_entries_by_dir_moved(self):
2222
 
        tree = self.make_branch_and_tree('tree')
2223
 
        self.build_tree(['tree/moved', 'tree/new_parent/'])
2224
 
        tree.add(['moved', 'new_parent'], ['moved-id', 'new_parent-id'])
2225
 
        tt = TreeTransform(tree)
2226
 
        tt.adjust_path('moved', tt.trans_id_file_id('new_parent-id'),
2227
 
                       tt.trans_id_file_id('moved-id'))
2228
 
        self.assertMatchingIterEntries(tt)
2229
 
 
2230
 
    def test_iter_entries_by_dir_specific_file_ids(self):
2231
 
        tree = self.make_branch_and_tree('tree')
2232
 
        tree.set_root_id('tree-root-id')
2233
 
        self.build_tree(['tree/parent/', 'tree/parent/child'])
2234
 
        tree.add(['parent', 'parent/child'], ['parent-id', 'child-id'])
2235
 
        tt = TreeTransform(tree)
2236
 
        self.assertMatchingIterEntries(tt, ['tree-root-id', 'child-id'])
2237
 
 
2238
 
    def test_symlink_content_summary(self):
2239
 
        self.requireFeature(SymlinkFeature)
2240
 
        preview = self.get_empty_preview()
2241
 
        preview.new_symlink('path', preview.root, 'target', 'path-id')
2242
 
        summary = preview.get_preview_tree().path_content_summary('path')
2243
 
        self.assertEqual(('symlink', None, None, 'target'), summary)
2244
 
 
2245
 
    def test_missing_content_summary(self):
2246
 
        preview = self.get_empty_preview()
2247
 
        summary = preview.get_preview_tree().path_content_summary('path')
2248
 
        self.assertEqual(('missing', None, None, None), summary)
2249
 
 
2250
 
    def test_deleted_content_summary(self):
2251
 
        tree = self.make_branch_and_tree('tree')
2252
 
        self.build_tree(['tree/path/'])
2253
 
        tree.add('path')
2254
 
        preview = TransformPreview(tree)
2255
 
        self.addCleanup(preview.finalize)
2256
 
        preview.delete_contents(preview.trans_id_tree_path('path'))
2257
 
        summary = preview.get_preview_tree().path_content_summary('path')
2258
 
        self.assertEqual(('missing', None, None, None), summary)
2259
 
 
2260
 
    def test_file_content_summary_executable(self):
2261
 
        if not osutils.supports_executable():
2262
 
            raise TestNotApplicable()
2263
 
        preview = self.get_empty_preview()
2264
 
        path_id = preview.new_file('path', preview.root, 'contents', 'path-id')
2265
 
        preview.set_executability(True, path_id)
2266
 
        summary = preview.get_preview_tree().path_content_summary('path')
2267
 
        self.assertEqual(4, len(summary))
2268
 
        self.assertEqual('file', summary[0])
2269
 
        # size must be known
2270
 
        self.assertEqual(len('contents'), summary[1])
2271
 
        # executable
2272
 
        self.assertEqual(True, summary[2])
2273
 
        # will not have hash (not cheap to determine)
2274
 
        self.assertIs(None, summary[3])
2275
 
 
2276
 
    def test_change_executability(self):
2277
 
        if not osutils.supports_executable():
2278
 
            raise TestNotApplicable()
2279
 
        tree = self.make_branch_and_tree('tree')
2280
 
        self.build_tree(['tree/path'])
2281
 
        tree.add('path')
2282
 
        preview = TransformPreview(tree)
2283
 
        self.addCleanup(preview.finalize)
2284
 
        path_id = preview.trans_id_tree_path('path')
2285
 
        preview.set_executability(True, path_id)
2286
 
        summary = preview.get_preview_tree().path_content_summary('path')
2287
 
        self.assertEqual(True, summary[2])
2288
 
 
2289
 
    def test_file_content_summary_non_exec(self):
2290
 
        preview = self.get_empty_preview()
2291
 
        preview.new_file('path', preview.root, 'contents', 'path-id')
2292
 
        summary = preview.get_preview_tree().path_content_summary('path')
2293
 
        self.assertEqual(4, len(summary))
2294
 
        self.assertEqual('file', summary[0])
2295
 
        # size must be known
2296
 
        self.assertEqual(len('contents'), summary[1])
2297
 
        # not executable
2298
 
        if osutils.supports_executable():
2299
 
            self.assertEqual(False, summary[2])
2300
 
        else:
2301
 
            self.assertEqual(None, summary[2])
2302
 
        # will not have hash (not cheap to determine)
2303
 
        self.assertIs(None, summary[3])
2304
 
 
2305
 
    def test_dir_content_summary(self):
2306
 
        preview = self.get_empty_preview()
2307
 
        preview.new_directory('path', preview.root, 'path-id')
2308
 
        summary = preview.get_preview_tree().path_content_summary('path')
2309
 
        self.assertEqual(('directory', None, None, None), summary)
2310
 
 
2311
 
    def test_tree_content_summary(self):
2312
 
        preview = self.get_empty_preview()
2313
 
        path = preview.new_directory('path', preview.root, 'path-id')
2314
 
        preview.set_tree_reference('rev-1', path)
2315
 
        summary = preview.get_preview_tree().path_content_summary('path')
2316
 
        self.assertEqual(4, len(summary))
2317
 
        self.assertEqual('tree-reference', summary[0])
2318
 
 
2319
 
    def test_annotate(self):
2320
 
        tree = self.make_branch_and_tree('tree')
2321
 
        self.build_tree_contents([('tree/file', 'a\n')])
2322
 
        tree.add('file', 'file-id')
2323
 
        tree.commit('a', rev_id='one')
2324
 
        self.build_tree_contents([('tree/file', 'a\nb\n')])
2325
 
        preview = TransformPreview(tree)
2326
 
        self.addCleanup(preview.finalize)
2327
 
        file_trans_id = preview.trans_id_file_id('file-id')
2328
 
        preview.delete_contents(file_trans_id)
2329
 
        preview.create_file('a\nb\nc\n', file_trans_id)
2330
 
        preview_tree = preview.get_preview_tree()
2331
 
        expected = [
2332
 
            ('one', 'a\n'),
2333
 
            ('me:', 'b\n'),
2334
 
            ('me:', 'c\n'),
2335
 
        ]
2336
 
        annotation = preview_tree.annotate_iter('file-id', 'me:')
2337
 
        self.assertEqual(expected, annotation)
2338
 
 
2339
 
    def test_annotate_missing(self):
2340
 
        preview = self.get_empty_preview()
2341
 
        preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
2342
 
        preview_tree = preview.get_preview_tree()
2343
 
        expected = [
2344
 
            ('me:', 'a\n'),
2345
 
            ('me:', 'b\n'),
2346
 
            ('me:', 'c\n'),
2347
 
         ]
2348
 
        annotation = preview_tree.annotate_iter('file-id', 'me:')
2349
 
        self.assertEqual(expected, annotation)
2350
 
 
2351
 
    def test_annotate_rename(self):
2352
 
        tree = self.make_branch_and_tree('tree')
2353
 
        self.build_tree_contents([('tree/file', 'a\n')])
2354
 
        tree.add('file', 'file-id')
2355
 
        tree.commit('a', rev_id='one')
2356
 
        preview = TransformPreview(tree)
2357
 
        self.addCleanup(preview.finalize)
2358
 
        file_trans_id = preview.trans_id_file_id('file-id')
2359
 
        preview.adjust_path('newname', preview.root, file_trans_id)
2360
 
        preview_tree = preview.get_preview_tree()
2361
 
        expected = [
2362
 
            ('one', 'a\n'),
2363
 
        ]
2364
 
        annotation = preview_tree.annotate_iter('file-id', 'me:')
2365
 
        self.assertEqual(expected, annotation)
2366
 
 
2367
 
    def test_annotate_deleted(self):
2368
 
        tree = self.make_branch_and_tree('tree')
2369
 
        self.build_tree_contents([('tree/file', 'a\n')])
2370
 
        tree.add('file', 'file-id')
2371
 
        tree.commit('a', rev_id='one')
2372
 
        self.build_tree_contents([('tree/file', 'a\nb\n')])
2373
 
        preview = TransformPreview(tree)
2374
 
        self.addCleanup(preview.finalize)
2375
 
        file_trans_id = preview.trans_id_file_id('file-id')
2376
 
        preview.delete_contents(file_trans_id)
2377
 
        preview_tree = preview.get_preview_tree()
2378
 
        annotation = preview_tree.annotate_iter('file-id', 'me:')
2379
 
        self.assertIs(None, annotation)
2380
 
 
2381
 
    def test_stored_kind(self):
2382
 
        preview = self.get_empty_preview()
2383
 
        preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
2384
 
        preview_tree = preview.get_preview_tree()
2385
 
        self.assertEqual('file', preview_tree.stored_kind('file-id'))
2386
 
 
2387
 
    def test_is_executable(self):
2388
 
        preview = self.get_empty_preview()
2389
 
        preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
2390
 
        preview.set_executability(True, preview.trans_id_file_id('file-id'))
2391
 
        preview_tree = preview.get_preview_tree()
2392
 
        self.assertEqual(True, preview_tree.is_executable('file-id'))
2393
 
 
2394
 
    def test_get_set_parent_ids(self):
2395
 
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2396
 
        self.assertEqual([], preview_tree.get_parent_ids())
2397
 
        preview_tree.set_parent_ids(['rev-1'])
2398
 
        self.assertEqual(['rev-1'], preview_tree.get_parent_ids())
2399
 
 
2400
 
    def test_plan_file_merge(self):
2401
 
        work_a = self.make_branch_and_tree('wta')
2402
 
        self.build_tree_contents([('wta/file', 'a\nb\nc\nd\n')])
2403
 
        work_a.add('file', 'file-id')
2404
 
        base_id = work_a.commit('base version')
2405
 
        tree_b = work_a.bzrdir.sprout('wtb').open_workingtree()
2406
 
        preview = TransformPreview(work_a)
2407
 
        self.addCleanup(preview.finalize)
2408
 
        trans_id = preview.trans_id_file_id('file-id')
2409
 
        preview.delete_contents(trans_id)
2410
 
        preview.create_file('b\nc\nd\ne\n', trans_id)
2411
 
        self.build_tree_contents([('wtb/file', 'a\nc\nd\nf\n')])
2412
 
        tree_a = preview.get_preview_tree()
2413
 
        tree_a.set_parent_ids([base_id])
2414
 
        self.assertEqual([
2415
 
            ('killed-a', 'a\n'),
2416
 
            ('killed-b', 'b\n'),
2417
 
            ('unchanged', 'c\n'),
2418
 
            ('unchanged', 'd\n'),
2419
 
            ('new-a', 'e\n'),
2420
 
            ('new-b', 'f\n'),
2421
 
        ], list(tree_a.plan_file_merge('file-id', tree_b)))
2422
 
 
2423
 
    def test_plan_file_merge_revision_tree(self):
2424
 
        work_a = self.make_branch_and_tree('wta')
2425
 
        self.build_tree_contents([('wta/file', 'a\nb\nc\nd\n')])
2426
 
        work_a.add('file', 'file-id')
2427
 
        base_id = work_a.commit('base version')
2428
 
        tree_b = work_a.bzrdir.sprout('wtb').open_workingtree()
2429
 
        preview = TransformPreview(work_a.basis_tree())
2430
 
        self.addCleanup(preview.finalize)
2431
 
        trans_id = preview.trans_id_file_id('file-id')
2432
 
        preview.delete_contents(trans_id)
2433
 
        preview.create_file('b\nc\nd\ne\n', trans_id)
2434
 
        self.build_tree_contents([('wtb/file', 'a\nc\nd\nf\n')])
2435
 
        tree_a = preview.get_preview_tree()
2436
 
        tree_a.set_parent_ids([base_id])
2437
 
        self.assertEqual([
2438
 
            ('killed-a', 'a\n'),
2439
 
            ('killed-b', 'b\n'),
2440
 
            ('unchanged', 'c\n'),
2441
 
            ('unchanged', 'd\n'),
2442
 
            ('new-a', 'e\n'),
2443
 
            ('new-b', 'f\n'),
2444
 
        ], list(tree_a.plan_file_merge('file-id', tree_b)))