/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

Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
54
54
                              build_tree, get_backup_name,
55
55
                              _FileMover, resolve_checkout,
56
56
                              TransformPreview, create_from_tree)
 
57
from bzrlib.util import bencode
 
58
 
57
59
 
58
60
class TestTreeTransform(tests.TestCaseWithTransport):
59
61
 
2013
2015
        resolve_conflicts(tt)
2014
2016
 
2015
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
 
2016
2025
class TestTransformPreview(tests.TestCaseWithTransport):
2017
2026
 
2018
2027
    def create_tree(self):
2090
2099
                          (False, False))],
2091
2100
                          list(preview_tree.iter_changes(revision_tree)))
2092
2101
 
2093
 
    def test_include_unchanged_value_error(self):
 
2102
    def test_include_unchanged_succeeds(self):
2094
2103
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2095
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
2096
 
                              revision_tree, include_unchanged=True)
2097
 
        self.assertEqual('include_unchanged is not supported', str(e))
 
2104
        changes = preview_tree.iter_changes(revision_tree,
 
2105
                                            include_unchanged=True)
 
2106
        root = revision_tree.inventory.root.file_id
 
2107
 
 
2108
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
2098
2109
 
2099
2110
    def test_specific_files(self):
2100
2111
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2101
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
2102
 
                              revision_tree, specific_files=['pete'])
2103
 
        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))
2104
2115
 
2105
 
    def test_want_unversioned_value_error(self):
 
2116
    def test_want_unversioned(self):
2106
2117
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2107
 
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
2108
 
                              revision_tree, want_unversioned=True)
2109
 
        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))
2110
2121
 
2111
2122
    def test_ignore_extra_trees_no_specific_files(self):
2112
2123
        # extra_trees is harmless without specific_files, so we'll silently
2574
2585
        self.assertEqual(False, preview_tree.is_executable('baz-id',
2575
2586
                                                           'tree/foo'))
2576
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))