← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testinv.py

  • Committer: Robert Collins
  • Date: 2005-10-09 22:59:39 UTC
  • Revision ID: robertc@robertcollins.net-20051009225939-abab7cf72ffdb97f
merge gustavos http_proxy fix for test cases.

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
                                  self.branch.get_transaction())
 
254
        # expected outcome - file_1 has a revision id of '2', and we can get
 
255
        # its text of 'file contents' out of the weave.
 
256
        self.assertEqual(self.file_1.revision, '1')
 
257
        self.assertEqual(self.file_active.revision, '2')
 
258
        # this should be a separate test probably, but lets check it once..
 
259
        lines = self.branch.weave_store.get_lines('fileid','2',
 
260
            self.branch.get_transaction())
 
261
        self.assertEqual(lines, ['contents of subdir/file\n'])
 
262
 
 
263
    def test_snapshot_unchanged(self):
 
264
        #This tests that a simple commit does not make a new entry for
 
265
        # an unchanged inventory entry
 
266
        self.file_active.snapshot('2', 'subdir/file', {'1':self.file_1},
 
267
                                  self.work_tree, self.branch.weave_store,
 
268
                                  self.branch.get_transaction())
 
269
        self.assertEqual(self.file_1.revision, '1')
 
270
        self.assertEqual(self.file_active.revision, '1')
 
271
        self.assertRaises(errors.WeaveError,
 
272
                          self.branch.weave_store.get_lines, 'fileid', '2',
 
273
                          self.branch.get_transaction())
 
274
 
 
275
    def test_snapshot_merge_identical_different_revid(self):
 
276
        # This tests that a commit with two identical parents, one of which has
 
277
        # a different revision id, results in a new revision id in the entry.
 
278
        # 1->other, commit a merge of other against 1, results in 2.
 
279
        other_ie = inventory.InventoryFile('fileid', 'newname', self.file_1.parent_id)
 
280
        other_ie = inventory.InventoryFile('fileid', 'file', self.file_1.parent_id)
 
281
        other_ie.revision = '1'
 
282
        other_ie.text_sha1 = self.file_1.text_sha1
 
283
        other_ie.text_size = self.file_1.text_size
 
284
        self.assertEqual(self.file_1, other_ie)
 
285
        other_ie.revision = 'other'
 
286
        self.assertNotEqual(self.file_1, other_ie)
 
287
        self.branch.weave_store.add_identical_text('fileid', '1', 'other', ['1'],
 
288
            self.branch.get_transaction())
 
289
        self.file_active.snapshot('2', 'subdir/file', 
 
290
                                  {'1':self.file_1, 'other':other_ie},
 
291
                                  self.work_tree, self.branch.weave_store,
 
292
                                  self.branch.get_transaction())
 
293
        self.assertEqual(self.file_active.revision, '2')
 
294
 
 
295
    def test_snapshot_changed(self):
 
296
        # This tests that a commit with one different parent results in a new
 
297
        # revision id in the entry.
 
298
        self.file_active.name='newname'
 
299
        rename('subdir/file', 'subdir/newname')
 
300
        self.file_active.snapshot('2', 'subdir/newname', {'1':self.file_1}, 
 
301
                                  self.work_tree, 
 
302
                                  self.branch.weave_store,
 
303
                                  self.branch.get_transaction())
 
304
        # expected outcome - file_1 has a revision id of '2'
 
305
        self.assertEqual(self.file_active.revision, '2')
 
306
 
 
307
 
 
308
class TestPreviousHeads(TestCaseInTempDir):
 
309
 
 
310
    def setUp(self):
 
311
        # we want several inventories, that respectively
 
312
        # give use the following scenarios:
 
313
        # A) fileid not in any inventory (A),
 
314
        # B) fileid present in one inventory (B) and (A,B)
 
315
        # C) fileid present in two inventories, and they
 
316
        #   are not mutual descendents (B, C)
 
317
        # D) fileid present in two inventories and one is
 
318
        #   a descendent of the other. (B, D)
 
319
        super(TestPreviousHeads, self).setUp()
 
320
        self.build_tree(['file'])
 
321
        self.branch = Branch.initialize('.')
 
322
        self.branch.commit('new branch', allow_pointless=True, rev_id='A')
 
323
        self.inv_A = self.branch.get_inventory('A')
 
324
        self.branch.add(['file'], ['fileid'])
 
325
        self.branch.commit('add file', rev_id='B')
 
326
        self.inv_B = self.branch.get_inventory('B')
 
327
        self.branch.put_controlfile('revision-history', 'A\n')
 
328
        self.assertEqual(self.branch.revision_history(), ['A'])
 
329
        self.branch.commit('another add of file', rev_id='C')
 
330
        self.inv_C = self.branch.get_inventory('C')
 
331
        self.branch.add_pending_merge('B')
 
332
        self.branch.commit('merge in B', rev_id='D')
 
333
        self.inv_D = self.branch.get_inventory('D')
 
334
        self.file_active = self.branch.working_tree().inventory['fileid']
 
335
        self.weave = self.branch.weave_store.get_weave('fileid',
 
336
            self.branch.get_transaction())
 
337
        
 
338
    def get_previous_heads(self, inventories):
 
339
        return self.file_active.find_previous_heads(inventories, self.weave)
 
340
        
 
341
    def test_fileid_in_no_inventory(self):
 
342
        self.assertEqual({}, self.get_previous_heads([self.inv_A]))
 
343
 
 
344
    def test_fileid_in_one_inventory(self):
 
345
        self.assertEqual({'B':self.inv_B['fileid']},
 
346
                         self.get_previous_heads([self.inv_B]))
 
347
        self.assertEqual({'B':self.inv_B['fileid']},
 
348
                         self.get_previous_heads([self.inv_A, self.inv_B]))
 
349
        self.assertEqual({'B':self.inv_B['fileid']},
 
350
                         self.get_previous_heads([self.inv_B, self.inv_A]))
 
351
 
 
352
    def test_fileid_in_two_inventories_gives_both_entries(self):
 
353
        self.assertEqual({'B':self.inv_B['fileid'],
 
354
                          'C':self.inv_C['fileid']},
 
355
                          self.get_previous_heads([self.inv_B, self.inv_C]))
 
356
        self.assertEqual({'B':self.inv_B['fileid'],
 
357
                          'C':self.inv_C['fileid']},
 
358
                          self.get_previous_heads([self.inv_C, self.inv_B]))
 
359
 
 
360
    def test_fileid_in_two_inventories_already_merged_gives_head(self):
 
361
        self.assertEqual({'D':self.inv_D['fileid']},
 
362
                         self.get_previous_heads([self.inv_B, self.inv_D]))
 
363
        self.assertEqual({'D':self.inv_D['fileid']},
 
364
                         self.get_previous_heads([self.inv_D, self.inv_B]))
 
365
 
 
366
    # TODO: test two inventories with the same file revision