← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testinv.py

Merge in format-5 work - release bzr 0.1rc1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testinv.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
from bzrlib.selftest import TestCase
 
17
from cStringIO import StringIO
 
18
import os
18
19
 
19
 
from bzrlib.inventory import Inventory, InventoryEntry
 
20
from bzrlib.branch import Branch
 
21
from bzrlib.clone import copy_branch
 
22
import bzrlib.errors as errors
 
23
from bzrlib.diff import internal_diff
 
24
from bzrlib.inventory import Inventory, ROOT_ID
 
25
import bzrlib.inventory as inventory
 
26
from bzrlib.osutils import has_symlinks, rename
 
27
from bzrlib.selftest import TestCase, TestCaseInTempDir
20
28
 
21
29
 
22
30
class TestInventory(TestCase):
23
31
 
24
32
    def test_is_within(self):
25
33
        from bzrlib.osutils import is_inside_any
26
 
        
27
 
        for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
28
 
                         (['src'], 'src/foo.c'),
 
34
 
 
35
        SRC_FOO_C = os.path.join('src', 'foo.c')
 
36
        for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
 
37
                         (['src'], SRC_FOO_C),
29
38
                         (['src'], 'src'),
30
39
                         ]:
31
40
            self.assert_(is_inside_any(dirs, fn))
57
66
        ie = inv.add_path('foo.txt', 'file')
58
67
        ## XXX
59
68
 
 
69
 
 
70
class TestInventoryEntry(TestCase):
 
71
 
 
72
    def test_file_kind_character(self):
 
73
        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
 
74
        self.assertEqual(file.kind_character(), '')
 
75
 
 
76
    def test_dir_kind_character(self):
 
77
        dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
 
78
        self.assertEqual(dir.kind_character(), '/')
 
79
 
 
80
    def test_link_kind_character(self):
 
81
        dir = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
 
82
        self.assertEqual(dir.kind_character(), '')
 
83
 
 
84
    def test_dir_detect_changes(self):
 
85
        left = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
 
86
        left.text_sha1 = 123
 
87
        left.executable = True
 
88
        left.symlink_target='foo'
 
89
        right = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
 
90
        right.text_sha1 = 321
 
91
        right.symlink_target='bar'
 
92
        self.assertEqual((False, False), left.detect_changes(right))
 
93
        self.assertEqual((False, False), right.detect_changes(left))
 
94
 
 
95
    def test_file_detect_changes(self):
 
96
        left = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
 
97
        left.text_sha1 = 123
 
98
        right = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
 
99
        right.text_sha1 = 123
 
100
        self.assertEqual((False, False), left.detect_changes(right))
 
101
        self.assertEqual((False, False), right.detect_changes(left))
 
102
        left.executable = True
 
103
        self.assertEqual((False, True), left.detect_changes(right))
 
104
        self.assertEqual((False, True), right.detect_changes(left))
 
105
        right.text_sha1 = 321
 
106
        self.assertEqual((True, True), left.detect_changes(right))
 
107
        self.assertEqual((True, True), right.detect_changes(left))
 
108
 
 
109
    def test_symlink_detect_changes(self):
 
110
        left = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
 
111
        left.text_sha1 = 123
 
112
        left.executable = True
 
113
        left.symlink_target='foo'
 
114
        right = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
 
115
        right.text_sha1 = 321
 
116
        right.symlink_target='foo'
 
117
        self.assertEqual((False, False), left.detect_changes(right))
 
118
        self.assertEqual((False, False), right.detect_changes(left))
 
119
        left.symlink_target = 'different'
 
120
        self.assertEqual((True, False), left.detect_changes(right))
 
121
        self.assertEqual((True, False), right.detect_changes(left))
 
122
 
 
123
    def test_file_has_text(self):
 
124
        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
 
125
        self.failUnless(file.has_text())
 
126
 
 
127
    def test_directory_has_text(self):
 
128
        dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
 
129
        self.failIf(dir.has_text())
 
130
 
 
131
    def test_link_has_text(self):
 
132
        link = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
 
133
        self.failIf(link.has_text())
 
134
 
 
135
 
 
136
class TestEntryDiffing(TestCaseInTempDir):
 
137
 
 
138
    def setUp(self):
 
139
        super(TestEntryDiffing, self).setUp()
 
140
        self.branch = Branch.initialize('.')
 
141
        print >> open('file', 'wb'), 'foo'
 
142
        self.branch.add(['file'], ['fileid'])
 
143
        if has_symlinks():
 
144
            os.symlink('target1', 'symlink')
 
145
            self.branch.add(['symlink'], ['linkid'])
 
146
        self.branch.commit('message_1', rev_id = '1')
 
147
        print >> open('file', 'wb'), 'bar'
 
148
        if has_symlinks():
 
149
            os.unlink('symlink')
 
150
            os.symlink('target2', 'symlink')
 
151
        self.tree_1 = self.branch.revision_tree('1')
 
152
        self.inv_1 = self.branch.get_inventory('1')
 
153
        self.file_1 = self.inv_1['fileid']
 
154
        self.tree_2 = self.branch.working_tree()
 
155
        self.inv_2 = self.branch.inventory
 
156
        self.file_2 = self.inv_2['fileid']
 
157
        if has_symlinks():
 
158
            self.link_1 = self.inv_1['linkid']
 
159
            self.link_2 = self.inv_2['linkid']
 
160
 
 
161
    def test_file_diff_deleted(self):
 
162
        output = StringIO()
 
163
        self.file_1.diff(internal_diff, 
 
164
                          "old_label", self.tree_1,
 
165
                          "/dev/null", None, None,
 
166
                          output)
 
167
        self.assertEqual(output.getvalue(), "--- old_label\n"
 
168
                                            "+++ /dev/null\n"
 
169
                                            "@@ -1,1 +0,0 @@\n"
 
170
                                            "-foo\n"
 
171
                                            "\n")
 
172
 
 
173
    def test_file_diff_added(self):
 
174
        output = StringIO()
 
175
        self.file_1.diff(internal_diff, 
 
176
                          "new_label", self.tree_1,
 
177
                          "/dev/null", None, None,
 
178
                          output, reverse=True)
 
179
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
 
180
                                            "+++ new_label\n"
 
181
                                            "@@ -0,0 +1,1 @@\n"
 
182
                                            "+foo\n"
 
183
                                            "\n")
 
184
 
 
185
    def test_file_diff_changed(self):
 
186
        output = StringIO()
 
187
        self.file_1.diff(internal_diff, 
 
188
                          "/dev/null", self.tree_1, 
 
189
                          "new_label", self.file_2, self.tree_2,
 
190
                          output)
 
191
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
 
192
                                            "+++ new_label\n"
 
193
                                            "@@ -1,1 +1,1 @@\n"
 
194
                                            "-foo\n"
 
195
                                            "+bar\n"
 
196
                                            "\n")
 
197
        
 
198
    def test_link_diff_deleted(self):
 
199
        output = StringIO()
 
200
        self.link_1.diff(internal_diff, 
 
201
                          "old_label", self.tree_1,
 
202
                          "/dev/null", None, None,
 
203
                          output)
 
204
        self.assertEqual(output.getvalue(),
 
205
                         "=== target was 'target1'\n")
 
206
 
 
207
    def test_link_diff_added(self):
 
208
        output = StringIO()
 
209
        self.link_1.diff(internal_diff, 
 
210
                          "new_label", self.tree_1,
 
211
                          "/dev/null", None, None,
 
212
                          output, reverse=True)
 
213
        self.assertEqual(output.getvalue(),
 
214
                         "=== target is 'target1'\n")
 
215
 
 
216
    def test_link_diff_changed(self):
 
217
        output = StringIO()
 
218
        self.link_1.diff(internal_diff, 
 
219
                          "/dev/null", self.tree_1, 
 
220
                          "new_label", self.link_2, self.tree_2,
 
221
                          output)
 
222
        self.assertEqual(output.getvalue(),
 
223
                         "=== target changed 'target1' => 'target2'\n")
 
224
 
 
225
 
 
226
class TestSnapshot(TestCaseInTempDir):
 
227
 
 
228
    def setUp(self):
 
229
        # for full testing we'll need a branch
 
230
        # with a subdir to test parent changes.
 
231
        # and a file, link and dir under that.
 
232
        # but right now I only need one attribute
 
233
        # to change, and then test merge patterns
 
234
        # with fake parent entries.
 
235
        super(TestSnapshot, self).setUp()
 
236
        self.branch = Branch.initialize('.')
 
237
        self.build_tree(['subdir/', 'subdir/file'])
 
238
        self.branch.add(['subdir', 'subdir/file'], ['dirid', 'fileid'])
 
239
        if has_symlinks():
 
240
            pass
 
241
        self.branch.commit('message_1', rev_id = '1')
 
242
        self.tree_1 = self.branch.revision_tree('1')
 
243
        self.inv_1 = self.branch.get_inventory('1')
 
244
        self.file_1 = self.inv_1['fileid']
 
245
        self.work_tree = self.branch.working_tree()
 
246
        self.file_active = self.work_tree.inventory['fileid']
 
247
 
 
248
    def test_snapshot_new_revision(self):
 
249
        # This tests that a simple commit with no parents makes a new
 
250
        # revision value in the inventory entry
 
251
        self.file_active.snapshot('2', 'subdir/file', {}, self.work_tree, 
 
252
                                  self.branch.weave_store)
 
253
        # expected outcome - file_1 has a revision id of '2', and we can get
 
254
        # its text of 'file contents' out of the weave.
 
255
        self.assertEqual(self.file_1.revision, '1')
 
256
        self.assertEqual(self.file_active.revision, '2')
 
257
        # this should be a separate test probably, but lets check it once..
 
258
        lines = self.branch.weave_store.get_lines('fileid','2')
 
259
        self.assertEqual(lines, ['contents of subdir/file\n'])
 
260
 
 
261
    def test_snapshot_unchanged(self):
 
262
        #This tests that a simple commit does not make a new entry for
 
263
        # an unchanged inventory entry
 
264
        self.file_active.snapshot('2', 'subdir/file', {'1':self.file_1},
 
265
                                  self.work_tree, self.branch.weave_store)
 
266
        self.assertEqual(self.file_1.revision, '1')
 
267
        self.assertEqual(self.file_active.revision, '1')
 
268
        self.assertRaises(errors.WeaveError,
 
269
                          self.branch.weave_store.get_lines, 'fileid', '2')
 
270
 
 
271
    def test_snapshot_merge_identical_different_revid(self):
 
272
        # This tests that a commit with two identical parents, one of which has
 
273
        # a different revision id, results in a new revision id in the entry.
 
274
        # 1->other, commit a merge of other against 1, results in 2.
 
275
        other_ie = inventory.InventoryFile('fileid', 'newname', self.file_1.parent_id)
 
276
        other_ie = inventory.InventoryFile('fileid', 'file', self.file_1.parent_id)
 
277
        other_ie.revision = '1'
 
278
        other_ie.text_sha1 = self.file_1.text_sha1
 
279
        other_ie.text_size = self.file_1.text_size
 
280
        self.assertEqual(self.file_1, other_ie)
 
281
        other_ie.revision = 'other'
 
282
        self.assertNotEqual(self.file_1, other_ie)
 
283
        self.branch.weave_store.add_identical_text('fileid', '1', 'other', ['1'])
 
284
        self.file_active.snapshot('2', 'subdir/file', 
 
285
                                  {'1':self.file_1, 'other':other_ie},
 
286
                                  self.work_tree, self.branch.weave_store)
 
287
        self.assertEqual(self.file_active.revision, '2')
 
288
 
 
289
    def test_snapshot_changed(self):
 
290
        # This tests that a commit with one different parent results in a new
 
291
        # revision id in the entry.
 
292
        self.file_active.name='newname'
 
293
        rename('subdir/file', 'subdir/newname')
 
294
        self.file_active.snapshot('2', 'subdir/newname', {'1':self.file_1}, 
 
295
                                  self.work_tree, 
 
296
                                  self.branch.weave_store)
 
297
        # expected outcome - file_1 has a revision id of '2'
 
298
        self.assertEqual(self.file_active.revision, '2')
 
299
 
 
300
 
 
301
class TestPreviousHeads(TestCaseInTempDir):
 
302
 
 
303
    def setUp(self):
 
304
        # we want several inventories, that respectively
 
305
        # give use the following scenarios:
 
306
        # A) fileid not in any inventory (A),
 
307
        # B) fileid present in one inventory (B) and (A,B)
 
308
        # C) fileid present in two inventories, and they
 
309
        #   are not mutual descendents (B, C)
 
310
        # D) fileid present in two inventories and one is
 
311
        #   a descendent of the other. (B, D)
 
312
        super(TestPreviousHeads, self).setUp()
 
313
        self.build_tree(['file'])
 
314
        self.branch = Branch.initialize('.')
 
315
        self.branch.commit('new branch', allow_pointless=True, rev_id='A')
 
316
        self.inv_A = self.branch.get_inventory('A')
 
317
        self.branch.add(['file'], ['fileid'])
 
318
        self.branch.commit('add file', rev_id='B')
 
319
        self.inv_B = self.branch.get_inventory('B')
 
320
        self.branch.put_controlfile('revision-history', 'A\n')
 
321
        self.assertEqual(self.branch.revision_history(), ['A'])
 
322
        self.branch.commit('another add of file', rev_id='C')
 
323
        self.inv_C = self.branch.get_inventory('C')
 
324
        self.branch.add_pending_merge('B')
 
325
        self.branch.commit('merge in B', rev_id='D')
 
326
        self.inv_D = self.branch.get_inventory('D')
 
327
        self.file_active = self.branch.working_tree().inventory['fileid']
 
328
        self.weave = self.branch.weave_store.get_weave('fileid')
 
329
        
 
330
    def get_previous_heads(self, inventories):
 
331
        return self.file_active.find_previous_heads(inventories, self.weave)
 
332
        
 
333
    def test_fileid_in_no_inventory(self):
 
334
        self.assertEqual({}, self.get_previous_heads([self.inv_A]))
 
335
 
 
336
    def test_fileid_in_one_inventory(self):
 
337
        self.assertEqual({'B':self.inv_B['fileid']},
 
338
                         self.get_previous_heads([self.inv_B]))
 
339
        self.assertEqual({'B':self.inv_B['fileid']},
 
340
                         self.get_previous_heads([self.inv_A, self.inv_B]))
 
341
        self.assertEqual({'B':self.inv_B['fileid']},
 
342
                         self.get_previous_heads([self.inv_B, self.inv_A]))
 
343
 
 
344
    def test_fileid_in_two_inventories_gives_both_entries(self):
 
345
        self.assertEqual({'B':self.inv_B['fileid'],
 
346
                          'C':self.inv_C['fileid']},
 
347
                          self.get_previous_heads([self.inv_B, self.inv_C]))
 
348
        self.assertEqual({'B':self.inv_B['fileid'],
 
349
                          'C':self.inv_C['fileid']},
 
350
                          self.get_previous_heads([self.inv_C, self.inv_B]))
 
351
 
 
352
    def test_fileid_in_two_inventories_already_merged_gives_head(self):
 
353
        self.assertEqual({'D':self.inv_D['fileid']},
 
354
                         self.get_previous_heads([self.inv_B, self.inv_D]))
 
355
        self.assertEqual({'D':self.inv_D['fileid']},
 
356
                         self.get_previous_heads([self.inv_D, self.inv_B]))
 
357
 
 
358
    # TODO: test two inventories with the same file revision