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

  • Committer: Ian Clatworthy
  • Date: 2008-12-15 06:18:29 UTC
  • mfrom: (3905 +trunk)
  • mto: (3586.1.23 views-ui)
  • mto: This revision was merged to the branch mainline in revision 4030.
  • Revision ID: ian.clatworthy@canonical.com-20081215061829-c8qwa93g71u9fsh5
merge bzr.dev 3905

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
40
40
                           ExistingPendingDeletion, ImmortalLimbo,
41
41
                           ImmortalPendingDeletion, LockError)
42
42
from bzrlib.osutils import file_kind, pathjoin
43
 
from bzrlib.merge import Merge3Merger
 
43
from bzrlib.merge import Merge3Merger, Merger
44
44
from bzrlib.tests import (
45
45
    CaseInsensitiveFilesystemFeature,
46
46
    HardlinkFeature,
53
53
                              resolve_conflicts, cook_conflicts, 
54
54
                              build_tree, get_backup_name,
55
55
                              _FileMover, resolve_checkout,
56
 
                              TransformPreview)
 
56
                              TransformPreview, create_from_tree)
 
57
from bzrlib.util import bencode
 
58
 
57
59
 
58
60
class TestTreeTransform(tests.TestCaseWithTransport):
59
61
 
1162
1164
        transform.cancel_creation(parent)
1163
1165
        transform.finalize()
1164
1166
 
1165
 
    def test_case_insensitive_clash(self):
1166
 
        self.requireFeature(CaseInsensitiveFilesystemFeature)
 
1167
    def test_rollback_on_directory_clash(self):
1167
1168
        def tt_helper():
1168
1169
            wt = self.make_branch_and_tree('.')
1169
1170
            tt = TreeTransform(wt)  # TreeTransform obtains write lock
1170
1171
            try:
1171
 
                tt.new_file('foo', tt.root, 'bar')
1172
 
                tt.new_file('Foo', tt.root, 'spam')
 
1172
                foo = tt.new_directory('foo', tt.root)
 
1173
                tt.new_file('bar', foo, 'foobar')
 
1174
                baz = tt.new_directory('baz', tt.root)
 
1175
                tt.new_file('qux', baz, 'quux')
 
1176
                # Ask for a rename 'foo' -> 'baz'
 
1177
                tt.adjust_path('baz', tt.root, foo)
1173
1178
                # Lie to tt that we've already resolved all conflicts.
1174
1179
                tt.apply(no_conflicts=True)
1175
1180
            except:
1176
1181
                wt.unlock()
1177
1182
                raise
 
1183
        # The rename will fail because the target directory is not empty (but
 
1184
        # raises FileExists anyway).
1178
1185
        err = self.assertRaises(errors.FileExists, tt_helper)
1179
1186
        self.assertContainsRe(str(err),
1180
 
            "^File exists: .+/foo")
 
1187
            "^File exists: .+/baz")
1181
1188
 
1182
1189
    def test_two_directories_clash(self):
1183
1190
        def tt_helper():
1186
1193
            try:
1187
1194
                foo_1 = tt.new_directory('foo', tt.root)
1188
1195
                tt.new_directory('bar', foo_1)
 
1196
                # Adding the same directory with a different content
1189
1197
                foo_2 = tt.new_directory('foo', tt.root)
1190
1198
                tt.new_directory('baz', foo_2)
1191
1199
                # Lie to tt that we've already resolved all conflicts.
1204
1212
            try:
1205
1213
                foo_1 = tt.new_directory('foo', tt.root)
1206
1214
                tt.new_directory('bar', foo_1)
 
1215
                # Adding the same directory with a different content
1207
1216
                foo_2 = tt.new_directory('foo', tt.root)
1208
1217
                tt.new_directory('baz', foo_2)
1209
1218
                # Lie to tt that we've already resolved all conflicts.
1219
1228
        wt = self.make_branch_and_tree('.')
1220
1229
        self.build_tree(['foo'])
1221
1230
        wt.add(['foo'])
 
1231
        wt.commit("one")
1222
1232
        tt = TreeTransform(wt)
1223
1233
        self.addCleanup(tt.finalize)
1224
1234
        foo_trans_id = tt.trans_id_tree_path("foo")
1229
1239
        tt.version_file("bar-1", bar_trans_id)
1230
1240
        tt.apply()
1231
1241
        self.failUnlessExists("foo/bar")
 
1242
        wt.lock_read()
 
1243
        try:
 
1244
            self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1245
                    "directory")
 
1246
        finally:
 
1247
            wt.unlock()
 
1248
        wt.commit("two")
 
1249
        changes = wt.changes_from(wt.basis_tree())
 
1250
        self.assertFalse(changes.has_changed(), changes)
 
1251
 
 
1252
    def test_file_to_symlink(self):
 
1253
        self.requireFeature(SymlinkFeature)
 
1254
        wt = self.make_branch_and_tree('.')
 
1255
        self.build_tree(['foo'])
 
1256
        wt.add(['foo'])
 
1257
        wt.commit("one")
 
1258
        tt = TreeTransform(wt)
 
1259
        self.addCleanup(tt.finalize)
 
1260
        foo_trans_id = tt.trans_id_tree_path("foo")
 
1261
        tt.delete_contents(foo_trans_id)
 
1262
        tt.create_symlink("bar", foo_trans_id)
 
1263
        tt.apply()
 
1264
        self.failUnlessExists("foo")
 
1265
        wt.lock_read()
 
1266
        self.addCleanup(wt.unlock)
 
1267
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1268
                "symlink")
 
1269
 
 
1270
    def test_dir_to_file(self):
 
1271
        wt = self.make_branch_and_tree('.')
 
1272
        self.build_tree(['foo/', 'foo/bar'])
 
1273
        wt.add(['foo', 'foo/bar'])
 
1274
        wt.commit("one")
 
1275
        tt = TreeTransform(wt)
 
1276
        self.addCleanup(tt.finalize)
 
1277
        foo_trans_id = tt.trans_id_tree_path("foo")
 
1278
        bar_trans_id = tt.trans_id_tree_path("foo/bar")
 
1279
        tt.delete_contents(foo_trans_id)
 
1280
        tt.delete_versioned(bar_trans_id)
 
1281
        tt.create_file(["aa\n"], foo_trans_id)
 
1282
        tt.apply()
 
1283
        self.failUnlessExists("foo")
 
1284
        wt.lock_read()
 
1285
        self.addCleanup(wt.unlock)
 
1286
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1287
                "file")
 
1288
 
 
1289
    def test_dir_to_hardlink(self):
 
1290
        self.requireFeature(HardlinkFeature)
 
1291
        wt = self.make_branch_and_tree('.')
 
1292
        self.build_tree(['foo/', 'foo/bar'])
 
1293
        wt.add(['foo', 'foo/bar'])
 
1294
        wt.commit("one")
 
1295
        tt = TreeTransform(wt)
 
1296
        self.addCleanup(tt.finalize)
 
1297
        foo_trans_id = tt.trans_id_tree_path("foo")
 
1298
        bar_trans_id = tt.trans_id_tree_path("foo/bar")
 
1299
        tt.delete_contents(foo_trans_id)
 
1300
        tt.delete_versioned(bar_trans_id)
 
1301
        self.build_tree(['baz'])
 
1302
        tt.create_hardlink("baz", foo_trans_id)
 
1303
        tt.apply()
 
1304
        self.failUnlessExists("foo")
 
1305
        self.failUnlessExists("baz")
 
1306
        wt.lock_read()
 
1307
        self.addCleanup(wt.unlock)
 
1308
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1309
                "file")
 
1310
 
 
1311
    def test_no_final_path(self):
 
1312
        transform, root = self.get_transform()
 
1313
        trans_id = transform.trans_id_file_id('foo')
 
1314
        transform.create_file('bar', trans_id)
 
1315
        transform.cancel_creation(trans_id)
 
1316
        transform.apply()
 
1317
 
 
1318
    def test_create_from_tree(self):
 
1319
        tree1 = self.make_branch_and_tree('tree1')
 
1320
        self.build_tree_contents([('tree1/foo/',), ('tree1/bar', 'baz')])
 
1321
        tree1.add(['foo', 'bar'], ['foo-id', 'bar-id'])
 
1322
        tree2 = self.make_branch_and_tree('tree2')
 
1323
        tt = TreeTransform(tree2)
 
1324
        foo_trans_id = tt.create_path('foo', tt.root)
 
1325
        create_from_tree(tt, foo_trans_id, tree1, 'foo-id')
 
1326
        bar_trans_id = tt.create_path('bar', tt.root)
 
1327
        create_from_tree(tt, bar_trans_id, tree1, 'bar-id')
 
1328
        tt.apply()
 
1329
        self.assertEqual('directory', osutils.file_kind('tree2/foo'))
 
1330
        self.assertFileEqual('baz', 'tree2/bar')
 
1331
 
 
1332
    def test_create_from_tree_bytes(self):
 
1333
        """Provided lines are used instead of tree content."""
 
1334
        tree1 = self.make_branch_and_tree('tree1')
 
1335
        self.build_tree_contents([('tree1/foo', 'bar'),])
 
1336
        tree1.add('foo', 'foo-id')
 
1337
        tree2 = self.make_branch_and_tree('tree2')
 
1338
        tt = TreeTransform(tree2)
 
1339
        foo_trans_id = tt.create_path('foo', tt.root)
 
1340
        create_from_tree(tt, foo_trans_id, tree1, 'foo-id', bytes='qux')
 
1341
        tt.apply()
 
1342
        self.assertFileEqual('qux', 'tree2/foo')
 
1343
 
 
1344
    def test_create_from_tree_symlink(self):
 
1345
        self.requireFeature(SymlinkFeature)
 
1346
        tree1 = self.make_branch_and_tree('tree1')
 
1347
        os.symlink('bar', 'tree1/foo')
 
1348
        tree1.add('foo', 'foo-id')
 
1349
        tt = TreeTransform(self.make_branch_and_tree('tree2'))
 
1350
        foo_trans_id = tt.create_path('foo', tt.root)
 
1351
        create_from_tree(tt, foo_trans_id, tree1, 'foo-id')
 
1352
        tt.apply()
 
1353
        self.assertEqual('bar', os.readlink('tree2/foo'))
1232
1354
 
1233
1355
 
1234
1356
class TransformGroup(object):
1893
2015
        resolve_conflicts(tt)
1894
2016
 
1895
2017
 
 
2018
A_ENTRY = ('a-id', ('a', 'a'), True, (True, True),
 
2019
                  ('TREE_ROOT', 'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
 
2020
                  (False, False))
 
2021
ROOT_ENTRY = ('TREE_ROOT', ('', ''), False, (True, True), (None, None),
 
2022
              ('', ''), ('directory', 'directory'), (False, None))
 
2023
 
 
2024
 
1896
2025
class TestTransformPreview(tests.TestCaseWithTransport):
1897
2026
 
1898
2027
    def create_tree(self):
1970
2099
                          (False, False))],
1971
2100
                          list(preview_tree.iter_changes(revision_tree)))
1972
2101
 
1973
 
    def test_wrong_tree_value_error(self):
 
2102
    def test_include_unchanged_succeeds(self):
1974
2103
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1975
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1976
 
                              preview_tree)
1977
 
        self.assertEqual('from_tree must be transform source tree.', str(e))
 
2104
        changes = preview_tree.iter_changes(revision_tree,
 
2105
                                            include_unchanged=True)
 
2106
        root = revision_tree.inventory.root.file_id
1978
2107
 
1979
 
    def test_include_unchanged_value_error(self):
1980
 
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1981
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1982
 
                              revision_tree, include_unchanged=True)
1983
 
        self.assertEqual('include_unchanged is not supported', str(e))
 
2108
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
1984
2109
 
1985
2110
    def test_specific_files(self):
1986
2111
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1987
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1988
 
                              revision_tree, specific_files=['pete'])
1989
 
        self.assertEqual('specific_files is not supported', str(e))
 
2112
        changes = preview_tree.iter_changes(revision_tree,
 
2113
                                            specific_files=[''])
 
2114
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
1990
2115
 
1991
 
    def test_want_unversioned_value_error(self):
 
2116
    def test_want_unversioned(self):
1992
2117
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1993
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1994
 
                              revision_tree, want_unversioned=True)
1995
 
        self.assertEqual('want_unversioned is not supported', str(e))
 
2118
        changes = preview_tree.iter_changes(revision_tree,
 
2119
                                            want_unversioned=True)
 
2120
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
1996
2121
 
1997
2122
    def test_ignore_extra_trees_no_specific_files(self):
1998
2123
        # extra_trees is harmless without specific_files, so we'll silently
2366
2491
            ('new-a', 'e\n'),
2367
2492
            ('new-b', 'f\n'),
2368
2493
        ], list(tree_a.plan_file_merge('file-id', tree_b)))
 
2494
 
 
2495
    def test_walkdirs(self):
 
2496
        preview = self.get_empty_preview()
 
2497
        preview.version_file('tree-root', preview.root)
 
2498
        preview_tree = preview.get_preview_tree()
 
2499
        file_trans_id = preview.new_file('a', preview.root, 'contents',
 
2500
                                         'a-id')
 
2501
        expected = [(('', 'tree-root'),
 
2502
                    [('a', 'a', 'file', None, 'a-id', 'file')])]
 
2503
        self.assertEqual(expected, list(preview_tree.walkdirs()))
 
2504
 
 
2505
    def test_extras(self):
 
2506
        work_tree = self.make_branch_and_tree('tree')
 
2507
        self.build_tree(['tree/removed-file', 'tree/existing-file',
 
2508
                         'tree/not-removed-file'])
 
2509
        work_tree.add(['removed-file', 'not-removed-file'])
 
2510
        preview = TransformPreview(work_tree)
 
2511
        self.addCleanup(preview.finalize)
 
2512
        preview.new_file('new-file', preview.root, 'contents')
 
2513
        preview.new_file('new-versioned-file', preview.root, 'contents',
 
2514
                         'new-versioned-id')
 
2515
        tree = preview.get_preview_tree()
 
2516
        preview.unversion_file(preview.trans_id_tree_path('removed-file'))
 
2517
        self.assertEqual(set(['new-file', 'removed-file', 'existing-file']),
 
2518
                         set(tree.extras()))
 
2519
 
 
2520
    def test_merge_into_preview(self):
 
2521
        work_tree = self.make_branch_and_tree('tree')
 
2522
        self.build_tree_contents([('tree/file','b\n')])
 
2523
        work_tree.add('file', 'file-id')
 
2524
        work_tree.commit('first commit')
 
2525
        child_tree = work_tree.bzrdir.sprout('child').open_workingtree()
 
2526
        self.build_tree_contents([('child/file','b\nc\n')])
 
2527
        child_tree.commit('child commit')
 
2528
        child_tree.lock_write()
 
2529
        self.addCleanup(child_tree.unlock)
 
2530
        work_tree.lock_write()
 
2531
        self.addCleanup(work_tree.unlock)
 
2532
        preview = TransformPreview(work_tree)
 
2533
        self.addCleanup(preview.finalize)
 
2534
        preview_tree = preview.get_preview_tree()
 
2535
        file_trans_id = preview.trans_id_file_id('file-id')
 
2536
        preview.delete_contents(file_trans_id)
 
2537
        preview.create_file('a\nb\n', file_trans_id)
 
2538
        pb = progress.DummyProgress()
 
2539
        merger = Merger.from_revision_ids(pb, preview_tree,
 
2540
                                          child_tree.branch.last_revision(),
 
2541
                                          other_branch=child_tree.branch,
 
2542
                                          tree_branch=work_tree.branch)
 
2543
        merger.merge_type = Merge3Merger
 
2544
        tt = merger.make_merger().make_preview_transform()
 
2545
        self.addCleanup(tt.finalize)
 
2546
        final_tree = tt.get_preview_tree()
 
2547
        self.assertEqual('a\nb\nc\n', final_tree.get_file_text('file-id'))
 
2548
 
 
2549
    def test_merge_preview_into_workingtree(self):
 
2550
        tree = self.make_branch_and_tree('tree')
 
2551
        tt = TransformPreview(tree)
 
2552
        self.addCleanup(tt.finalize)
 
2553
        tt.new_file('name', tt.root, 'content', 'file-id')
 
2554
        tree2 = self.make_branch_and_tree('tree2')
 
2555
        pb = progress.DummyProgress()
 
2556
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
 
2557
                                         pb, tree.basis_tree())
 
2558
        merger.merge_type = Merge3Merger
 
2559
        merger.do_merge()
 
2560
 
 
2561
    def test_merge_preview_into_workingtree_handles_conflicts(self):
 
2562
        tree = self.make_branch_and_tree('tree')
 
2563
        self.build_tree_contents([('tree/foo', 'bar')])
 
2564
        tree.add('foo', 'foo-id')
 
2565
        tree.commit('foo')
 
2566
        tt = TransformPreview(tree)
 
2567
        self.addCleanup(tt.finalize)
 
2568
        trans_id = tt.trans_id_file_id('foo-id')
 
2569
        tt.delete_contents(trans_id)
 
2570
        tt.create_file('baz', trans_id)
 
2571
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
2572
        self.build_tree_contents([('tree2/foo', 'qux')])
 
2573
        pb = progress.DummyProgress()
 
2574
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
 
2575
                                         pb, tree.basis_tree())
 
2576
        merger.merge_type = Merge3Merger
 
2577
        merger.do_merge()
 
2578
 
 
2579
    def test_is_executable(self):
 
2580
        tree = self.make_branch_and_tree('tree')
 
2581
        preview = TransformPreview(tree)
 
2582
        self.addCleanup(preview.finalize)
 
2583
        preview.new_file('foo', preview.root, 'bar', 'baz-id')
 
2584
        preview_tree = preview.get_preview_tree()
 
2585
        self.assertEqual(False, preview_tree.is_executable('baz-id',
 
2586
                                                           'tree/foo'))
 
2587
        self.assertEqual(False, preview_tree.is_executable('baz-id'))
 
2588
 
 
2589
 
 
2590
class FakeSerializer(object):
 
2591
    """Serializer implementation that simply returns the input.
 
2592
 
 
2593
    The input is returned in the order used by pack.ContainerPushParser.
 
2594
    """
 
2595
    @staticmethod
 
2596
    def bytes_record(bytes, names):
 
2597
        return names, bytes
 
2598
 
 
2599
 
 
2600
class TestSerializeTransform(tests.TestCaseWithTransport):
 
2601
 
 
2602
    _test_needs_features = [tests.UnicodeFilenameFeature]
 
2603
 
 
2604
    def get_preview(self, tree=None):
 
2605
        if tree is None:
 
2606
            tree = self.make_branch_and_tree('tree')
 
2607
        tt = TransformPreview(tree)
 
2608
        self.addCleanup(tt.finalize)
 
2609
        return tt
 
2610
 
 
2611
    def assertSerializesTo(self, expected, tt):
 
2612
        records = list(tt.serialize(FakeSerializer()))
 
2613
        self.assertEqual(expected, records)
 
2614
 
 
2615
    @staticmethod
 
2616
    def default_attribs():
 
2617
        return {
 
2618
            '_id_number': 1,
 
2619
            '_new_name': {},
 
2620
            '_new_parent': {},
 
2621
            '_new_executability': {},
 
2622
            '_new_id': {},
 
2623
            '_tree_path_ids': {'': 'new-0'},
 
2624
            '_removed_id': [],
 
2625
            '_removed_contents': [],
 
2626
            '_non_present_ids': {},
 
2627
            }
 
2628
 
 
2629
    def make_records(self, attribs, contents):
 
2630
        records = [
 
2631
            (((('attribs'),),), bencode.bencode(attribs))]
 
2632
        records.extend([(((n, k),), c) for n, k, c in contents])
 
2633
        return records
 
2634
 
 
2635
    def creation_records(self):
 
2636
        attribs = self.default_attribs()
 
2637
        attribs['_id_number'] = 3
 
2638
        attribs['_new_name'] = {
 
2639
            'new-1': u'foo\u1234'.encode('utf-8'), 'new-2': 'qux'}
 
2640
        attribs['_new_id'] = {'new-1': 'baz', 'new-2': 'quxx'}
 
2641
        attribs['_new_parent'] = {'new-1': 'new-0', 'new-2': 'new-0'}
 
2642
        attribs['_new_executability'] = {'new-1': 1}
 
2643
        contents = [
 
2644
            ('new-1', 'file', 'i 1\nbar\n'),
 
2645
            ('new-2', 'directory', ''),
 
2646
            ]
 
2647
        return self.make_records(attribs, contents)
 
2648
 
 
2649
    def test_serialize_creation(self):
 
2650
        tt = self.get_preview()
 
2651
        tt.new_file(u'foo\u1234', tt.root, 'bar', 'baz', True)
 
2652
        tt.new_directory('qux', tt.root, 'quxx')
 
2653
        self.assertSerializesTo(self.creation_records(), tt)
 
2654
 
 
2655
    def test_deserialize_creation(self):
 
2656
        tt = self.get_preview()
 
2657
        tt.deserialize(iter(self.creation_records()))
 
2658
        self.assertEqual(3, tt._id_number)
 
2659
        self.assertEqual({'new-1': u'foo\u1234',
 
2660
                          'new-2': 'qux'}, tt._new_name)
 
2661
        self.assertEqual({'new-1': 'baz', 'new-2': 'quxx'}, tt._new_id)
 
2662
        self.assertEqual({'new-1': tt.root, 'new-2': tt.root}, tt._new_parent)
 
2663
        self.assertEqual({'baz': 'new-1', 'quxx': 'new-2'}, tt._r_new_id)
 
2664
        self.assertEqual({'new-1': True}, tt._new_executability)
 
2665
        self.assertEqual({'new-1': 'file',
 
2666
                          'new-2': 'directory'}, tt._new_contents)
 
2667
        foo_limbo = open(tt._limbo_name('new-1'), 'rb')
 
2668
        try:
 
2669
            foo_content = foo_limbo.read()
 
2670
        finally:
 
2671
            foo_limbo.close()
 
2672
        self.assertEqual('bar', foo_content)
 
2673
 
 
2674
    def symlink_creation_records(self):
 
2675
        attribs = self.default_attribs()
 
2676
        attribs['_id_number'] = 2
 
2677
        attribs['_new_name'] = {'new-1': u'foo\u1234'.encode('utf-8')}
 
2678
        attribs['_new_parent'] = {'new-1': 'new-0'}
 
2679
        contents = [('new-1', 'symlink', u'bar\u1234'.encode('utf-8'))]
 
2680
        return self.make_records(attribs, contents)
 
2681
 
 
2682
    def test_serialize_symlink_creation(self):
 
2683
        self.requireFeature(tests.SymlinkFeature)
 
2684
        tt = self.get_preview()
 
2685
        tt.new_symlink(u'foo\u1234', tt.root, u'bar\u1234')
 
2686
        self.assertSerializesTo(self.symlink_creation_records(), tt)
 
2687
 
 
2688
    def test_deserialize_symlink_creation(self):
 
2689
        tt = self.get_preview()
 
2690
        tt.deserialize(iter(self.symlink_creation_records()))
 
2691
        # XXX readlink should be returning unicode, not utf-8
 
2692
        foo_content = os.readlink(tt._limbo_name('new-1')).decode('utf-8')
 
2693
        self.assertEqual(u'bar\u1234', foo_content)
 
2694
 
 
2695
    def make_destruction_preview(self):
 
2696
        tree = self.make_branch_and_tree('.')
 
2697
        self.build_tree([u'foo\u1234', 'bar'])
 
2698
        tree.add([u'foo\u1234', 'bar'], ['foo-id', 'bar-id'])
 
2699
        return self.get_preview(tree)
 
2700
 
 
2701
    def destruction_records(self):
 
2702
        attribs = self.default_attribs()
 
2703
        attribs['_id_number'] = 3
 
2704
        attribs['_removed_id'] = ['new-1']
 
2705
        attribs['_removed_contents'] = ['new-2']
 
2706
        attribs['_tree_path_ids'] = {
 
2707
            '': 'new-0',
 
2708
            u'foo\u1234'.encode('utf-8'): 'new-1',
 
2709
            'bar': 'new-2',
 
2710
            }
 
2711
        return self.make_records(attribs, [])
 
2712
 
 
2713
    def test_serialize_destruction(self):
 
2714
        tt = self.make_destruction_preview()
 
2715
        foo_trans_id = tt.trans_id_tree_file_id('foo-id')
 
2716
        tt.unversion_file(foo_trans_id)
 
2717
        bar_trans_id = tt.trans_id_tree_file_id('bar-id')
 
2718
        tt.delete_contents(bar_trans_id)
 
2719
        self.assertSerializesTo(self.destruction_records(), tt)
 
2720
 
 
2721
    def test_deserialize_destruction(self):
 
2722
        tt = self.make_destruction_preview()
 
2723
        tt.deserialize(iter(self.destruction_records()))
 
2724
        self.assertEqual({u'foo\u1234': 'new-1',
 
2725
                          'bar': 'new-2',
 
2726
                          '': tt.root}, tt._tree_path_ids)
 
2727
        self.assertEqual({'new-1': u'foo\u1234',
 
2728
                          'new-2': 'bar',
 
2729
                          tt.root: ''}, tt._tree_id_paths)
 
2730
        self.assertEqual(set(['new-1']), tt._removed_id)
 
2731
        self.assertEqual(set(['new-2']), tt._removed_contents)
 
2732
 
 
2733
    def missing_records(self):
 
2734
        attribs = self.default_attribs()
 
2735
        attribs['_id_number'] = 2
 
2736
        attribs['_non_present_ids'] = {
 
2737
            'boo': 'new-1',}
 
2738
        return self.make_records(attribs, [])
 
2739
 
 
2740
    def test_serialize_missing(self):
 
2741
        tt = self.get_preview()
 
2742
        boo_trans_id = tt.trans_id_file_id('boo')
 
2743
        self.assertSerializesTo(self.missing_records(), tt)
 
2744
 
 
2745
    def test_deserialize_missing(self):
 
2746
        tt = self.get_preview()
 
2747
        tt.deserialize(iter(self.missing_records()))
 
2748
        self.assertEqual({'boo': 'new-1'}, tt._non_present_ids)
 
2749
 
 
2750
    def make_modification_preview(self):
 
2751
        LINES_ONE = 'aa\nbb\ncc\ndd\n'
 
2752
        LINES_TWO = 'z\nbb\nx\ndd\n'
 
2753
        tree = self.make_branch_and_tree('tree')
 
2754
        self.build_tree_contents([('tree/file', LINES_ONE)])
 
2755
        tree.add('file', 'file-id')
 
2756
        return self.get_preview(tree), LINES_TWO
 
2757
 
 
2758
    def modification_records(self):
 
2759
        attribs = self.default_attribs()
 
2760
        attribs['_id_number'] = 2
 
2761
        attribs['_tree_path_ids'] = {
 
2762
            'file': 'new-1',
 
2763
            '': 'new-0',}
 
2764
        attribs['_removed_contents'] = ['new-1']
 
2765
        contents = [('new-1', 'file',
 
2766
                     'i 1\nz\n\nc 0 1 1 1\ni 1\nx\n\nc 0 3 3 1\n')]
 
2767
        return self.make_records(attribs, contents)
 
2768
 
 
2769
    def test_serialize_modification(self):
 
2770
        tt, LINES = self.make_modification_preview()
 
2771
        trans_id = tt.trans_id_file_id('file-id')
 
2772
        tt.delete_contents(trans_id)
 
2773
        tt.create_file(LINES, trans_id)
 
2774
        self.assertSerializesTo(self.modification_records(), tt)
 
2775
 
 
2776
    def test_deserialize_modification(self):
 
2777
        tt, LINES = self.make_modification_preview()
 
2778
        tt.deserialize(iter(self.modification_records()))
 
2779
        self.assertFileEqual(LINES, tt._limbo_name('new-1'))
 
2780
 
 
2781
    def make_kind_change_preview(self):
 
2782
        LINES = 'a\nb\nc\nd\n'
 
2783
        tree = self.make_branch_and_tree('tree')
 
2784
        self.build_tree(['tree/foo/'])
 
2785
        tree.add('foo', 'foo-id')
 
2786
        return self.get_preview(tree), LINES
 
2787
 
 
2788
    def kind_change_records(self):
 
2789
        attribs = self.default_attribs()
 
2790
        attribs['_id_number'] = 2
 
2791
        attribs['_tree_path_ids'] = {
 
2792
            'foo': 'new-1',
 
2793
            '': 'new-0',}
 
2794
        attribs['_removed_contents'] = ['new-1']
 
2795
        contents = [('new-1', 'file',
 
2796
                     'i 4\na\nb\nc\nd\n\n')]
 
2797
        return self.make_records(attribs, contents)
 
2798
 
 
2799
    def test_serialize_kind_change(self):
 
2800
        tt, LINES = self.make_kind_change_preview()
 
2801
        trans_id = tt.trans_id_file_id('foo-id')
 
2802
        tt.delete_contents(trans_id)
 
2803
        tt.create_file(LINES, trans_id)
 
2804
        self.assertSerializesTo(self.kind_change_records(), tt)
 
2805
 
 
2806
    def test_deserialize_kind_change(self):
 
2807
        tt, LINES = self.make_kind_change_preview()
 
2808
        tt.deserialize(iter(self.kind_change_records()))
 
2809
        self.assertFileEqual(LINES, tt._limbo_name('new-1'))
 
2810
 
 
2811
    def make_add_contents_preview(self):
 
2812
        LINES = 'a\nb\nc\nd\n'
 
2813
        tree = self.make_branch_and_tree('tree')
 
2814
        self.build_tree(['tree/foo'])
 
2815
        tree.add('foo')
 
2816
        os.unlink('tree/foo')
 
2817
        return self.get_preview(tree), LINES
 
2818
 
 
2819
    def add_contents_records(self):
 
2820
        attribs = self.default_attribs()
 
2821
        attribs['_id_number'] = 2
 
2822
        attribs['_tree_path_ids'] = {
 
2823
            'foo': 'new-1',
 
2824
            '': 'new-0',}
 
2825
        contents = [('new-1', 'file',
 
2826
                     'i 4\na\nb\nc\nd\n\n')]
 
2827
        return self.make_records(attribs, contents)
 
2828
 
 
2829
    def test_serialize_add_contents(self):
 
2830
        tt, LINES = self.make_add_contents_preview()
 
2831
        trans_id = tt.trans_id_tree_path('foo')
 
2832
        tt.create_file(LINES, trans_id)
 
2833
        self.assertSerializesTo(self.add_contents_records(), tt)
 
2834
 
 
2835
    def test_deserialize_add_contents(self):
 
2836
        tt, LINES = self.make_add_contents_preview()
 
2837
        tt.deserialize(iter(self.add_contents_records()))
 
2838
        self.assertFileEqual(LINES, tt._limbo_name('new-1'))
 
2839
 
 
2840
    def test_get_parents_lines(self):
 
2841
        LINES_ONE = 'aa\nbb\ncc\ndd\n'
 
2842
        LINES_TWO = 'z\nbb\nx\ndd\n'
 
2843
        tree = self.make_branch_and_tree('tree')
 
2844
        self.build_tree_contents([('tree/file', LINES_ONE)])
 
2845
        tree.add('file', 'file-id')
 
2846
        tt = self.get_preview(tree)
 
2847
        trans_id = tt.trans_id_tree_path('file')
 
2848
        self.assertEqual((['aa\n', 'bb\n', 'cc\n', 'dd\n'],),
 
2849
            tt._get_parents_lines(trans_id))
 
2850
 
 
2851
    def test_get_parents_texts(self):
 
2852
        LINES_ONE = 'aa\nbb\ncc\ndd\n'
 
2853
        LINES_TWO = 'z\nbb\nx\ndd\n'
 
2854
        tree = self.make_branch_and_tree('tree')
 
2855
        self.build_tree_contents([('tree/file', LINES_ONE)])
 
2856
        tree.add('file', 'file-id')
 
2857
        tt = self.get_preview(tree)
 
2858
        trans_id = tt.trans_id_tree_path('file')
 
2859
        self.assertEqual((LINES_ONE,),
 
2860
            tt._get_parents_texts(trans_id))