← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/tree_implementations/test_inv.py

Merge bzr.dev and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/tree_implementations/test_inv.py
1
 
# Copyright (C) 2007 Canonical Ltd
 
1
# Copyright (C) 2007, 2008 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
23
23
from bzrlib.diff import internal_diff
24
24
from bzrlib.mutabletree import MutableTree
25
25
from bzrlib.osutils import has_symlinks
26
 
from bzrlib.symbol_versioning import zero_ninetyone, one_zero
27
26
from bzrlib.tests import SymlinkFeature, TestSkipped
28
27
from bzrlib.tests.tree_implementations import TestCaseWithTree
 
28
from bzrlib.transform import _PreviewTree
29
29
from bzrlib.uncommit import uncommit
30
30
 
31
31
 
32
 
class TestEntryDiffing(TestCaseWithTree):
33
 
 
34
 
    def setUp(self):
35
 
        super(TestEntryDiffing, self).setUp()
36
 
        self.wt = self.make_branch_and_tree('.')
37
 
        self.branch = self.wt.branch
38
 
        open('file', 'wb').write('foo\n')
39
 
        open('binfile', 'wb').write('foo\n')
40
 
        self.wt.add(['file'], ['fileid'])
41
 
        self.wt.add(['binfile'], ['binfileid'])
42
 
        if has_symlinks():
43
 
            os.symlink('target1', 'symlink')
44
 
            self.wt.add(['symlink'], ['linkid'])
45
 
        self.wt.commit('message_1', rev_id = '1')
46
 
        open('file', 'wb').write('bar\n')
47
 
        open('binfile', 'wb').write('x' * 1023 + '\x00\n')
48
 
        if has_symlinks():
49
 
            os.unlink('symlink')
50
 
            os.symlink('target2', 'symlink')
51
 
        self.tree_1 = self.branch.repository.revision_tree('1')
52
 
        self.inv_1 = self.branch.repository.get_inventory('1')
53
 
        self.file_1 = self.inv_1['fileid']
54
 
        self.file_1b = self.inv_1['binfileid']
55
 
        self.tree_2 = self.workingtree_to_test_tree(self.wt)
56
 
        self.tree_2.lock_read()
57
 
        self.addCleanup(self.tree_2.unlock)
58
 
        self.inv_2 = self.tree_2.inventory
59
 
        self.file_2 = self.inv_2['fileid']
60
 
        self.file_2b = self.inv_2['binfileid']
61
 
        if has_symlinks():
62
 
            self.link_1 = self.inv_1['linkid']
63
 
            self.link_2 = self.inv_2['linkid']
64
 
 
65
 
    def test_file_diff_deleted(self):
66
 
        output = StringIO()
67
 
        self.applyDeprecated(one_zero,
68
 
                             self.file_1.diff,
69
 
                             internal_diff,
70
 
                             "old_label", self.tree_1,
71
 
                             "/dev/null", None, None,
72
 
                             output)
73
 
        self.assertEqual(output.getvalue(), "--- old_label\n"
74
 
                                            "+++ /dev/null\n"
75
 
                                            "@@ -1,1 +0,0 @@\n"
76
 
                                            "-foo\n"
77
 
                                            "\n")
78
 
 
79
 
    def test_file_diff_added(self):
80
 
        output = StringIO()
81
 
        self.applyDeprecated(one_zero,
82
 
                             self.file_1.diff,
83
 
                             internal_diff,
84
 
                             "new_label", self.tree_1,
85
 
                             "/dev/null", None, None,
86
 
                             output, reverse=True)
87
 
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
88
 
                                            "+++ new_label\n"
89
 
                                            "@@ -0,0 +1,1 @@\n"
90
 
                                            "+foo\n"
91
 
                                            "\n")
92
 
 
93
 
    def test_file_diff_changed(self):
94
 
        output = StringIO()
95
 
        self.applyDeprecated(one_zero,
96
 
                             self.file_1.diff,
97
 
                             internal_diff,
98
 
                             "/dev/null", self.tree_1,
99
 
                             "new_label", self.file_2, self.tree_2,
100
 
                             output)
101
 
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
102
 
                                            "+++ new_label\n"
103
 
                                            "@@ -1,1 +1,1 @@\n"
104
 
                                            "-foo\n"
105
 
                                            "+bar\n"
106
 
                                            "\n")
107
 
        
108
 
    def test_file_diff_binary(self):
109
 
        output = StringIO()
110
 
        self.applyDeprecated(one_zero,
111
 
                             self.file_1.diff,
112
 
                             internal_diff,
113
 
                             "/dev/null", self.tree_1,
114
 
                             "new_label", self.file_2b, self.tree_2,
115
 
                             output)
116
 
        self.assertEqual(output.getvalue(), 
117
 
                         "Binary files /dev/null and new_label differ\n")
118
 
 
119
 
    def test_link_diff_deleted(self):
120
 
        self.requireFeature(SymlinkFeature)
121
 
        output = StringIO()
122
 
        self.applyDeprecated(one_zero,
123
 
                             self.link_1.diff,
124
 
                             internal_diff, "old_label",
125
 
                             self.tree_1, "/dev/null", None, None,
126
 
                             output)
127
 
        self.assertEqual(output.getvalue(),
128
 
                         "=== target was 'target1'\n")
129
 
 
130
 
    def test_link_diff_added(self):
131
 
        self.requireFeature(SymlinkFeature)
132
 
        output = StringIO()
133
 
        self.applyDeprecated(one_zero,
134
 
                             self.link_1.diff,
135
 
                             internal_diff,
136
 
                             "new_label", self.tree_1,
137
 
                             "/dev/null", None, None,
138
 
                             output, reverse=True)
139
 
        self.assertEqual(output.getvalue(),
140
 
                         "=== target is 'target1'\n")
141
 
 
142
 
    def test_link_diff_changed(self):
143
 
        self.requireFeature(SymlinkFeature)
144
 
        output = StringIO()
145
 
        self.applyDeprecated(one_zero,
146
 
                             self.link_1.diff,
147
 
                             internal_diff,
148
 
                             "/dev/null", self.tree_1,
149
 
                             "new_label", self.link_2, self.tree_2,
150
 
                             output)
151
 
        self.assertEqual(output.getvalue(),
152
 
                         "=== target changed 'target1' => 'target2'\n")
 
32
def get_entry(tree, file_id):
 
33
    return tree.iter_entries_by_dir([file_id]).next()[1]
153
34
 
154
35
 
155
36
class TestPreviousHeads(TestCaseWithTree):
182
63
        self.tree = self.workingtree_to_test_tree(self.wt)
183
64
        self.tree.lock_read()
184
65
        self.addCleanup(self.tree.unlock)
185
 
        self.file_active = self.tree.inventory['fileid']
 
66
        self.file_active = get_entry(self.tree, 'fileid')
186
67
        self.weave = self.branch.repository.weave_store.get_weave('fileid',
187
68
            self.branch.repository.get_transaction())
188
 
        
189
 
    def get_previous_heads(self, inventories):
190
 
        return self.applyDeprecated(zero_ninetyone,
191
 
            self.file_active.find_previous_heads,
192
 
            inventories,
193
 
            self.branch.repository.weave_store,
194
 
            self.branch.repository.get_transaction())
195
 
        
196
 
    def test_fileid_in_no_inventory(self):
197
 
        self.assertEqual({}, self.get_previous_heads([self.inv_A]))
198
 
 
199
 
    def test_fileid_in_one_inventory(self):
200
 
        self.assertEqual({'B':self.inv_B['fileid']},
201
 
                         self.get_previous_heads([self.inv_B]))
202
 
        self.assertEqual({'B':self.inv_B['fileid']},
203
 
                         self.get_previous_heads([self.inv_A, self.inv_B]))
204
 
        self.assertEqual({'B':self.inv_B['fileid']},
205
 
                         self.get_previous_heads([self.inv_B, self.inv_A]))
206
 
 
207
 
    def test_fileid_in_two_inventories_gives_both_entries(self):
208
 
        self.assertEqual({'B':self.inv_B['fileid'],
209
 
                          'C':self.inv_C['fileid']},
210
 
                          self.get_previous_heads([self.inv_B, self.inv_C]))
211
 
        self.assertEqual({'B':self.inv_B['fileid'],
212
 
                          'C':self.inv_C['fileid']},
213
 
                          self.get_previous_heads([self.inv_C, self.inv_B]))
214
 
 
215
 
    def test_fileid_in_two_inventories_already_merged_gives_head(self):
216
 
        self.assertEqual({'D':self.inv_D['fileid']},
217
 
                         self.get_previous_heads([self.inv_B, self.inv_D]))
218
 
        self.assertEqual({'D':self.inv_D['fileid']},
219
 
                         self.get_previous_heads([self.inv_D, self.inv_B]))
220
 
 
221
 
    # TODO: test two inventories with the same file revision 
 
69
 
 
70
    # TODO: test two inventories with the same file revision
222
71
 
223
72
 
224
73
class TestInventory(TestCaseWithTree):
227
76
        self.tree = self.get_tree_with_subdirs_and_all_content_types()
228
77
        self.tree.lock_read()
229
78
        self.addCleanup(self.tree.unlock)
230
 
        # Commenting out the following line still fails.
231
 
        self.inv = self.tree.inventory
232
79
 
233
80
    def test_symlink_target(self):
234
81
        self.requireFeature(SymlinkFeature)
235
82
        self._set_up()
236
 
        if isinstance(self.tree, MutableTree):
 
83
        if isinstance(self.tree, (MutableTree, _PreviewTree)):
237
84
            raise TestSkipped(
238
 
                'symlinks not accurately represented in working trees')
239
 
        entry = self.inv[self.inv.path2id('symlink')]
 
85
                'symlinks not accurately represented in working trees and'
 
86
                ' preview trees')
 
87
        entry = get_entry(self.tree, self.tree.path2id('symlink'))
240
88
        self.assertEqual(entry.symlink_target, 'link-target')
241
89
 
 
90
    def test_symlink_target_tree(self):
 
91
        self.requireFeature(SymlinkFeature)
 
92
        self._set_up()
 
93
        self.assertEqual('link-target',
 
94
                         self.tree.get_symlink_target('symlink'))
 
95
 
 
96
    def test_kind_symlink(self):
 
97
        self.requireFeature(SymlinkFeature)
 
98
        self._set_up()
 
99
        self.assertEqual('symlink', self.tree.kind('symlink'))
 
100
        self.assertIs(None, self.tree.get_file_size('symlink'))
 
101
 
242
102
    def test_symlink(self):
243
103
        self.requireFeature(SymlinkFeature)
244
104
        self._set_up()
245
 
        entry = self.inv[self.inv.path2id('symlink')]
 
105
        entry = get_entry(self.tree, self.tree.path2id('symlink'))
246
106
        self.assertEqual(entry.kind, 'symlink')
247
107
        self.assertEqual(None, entry.text_size)