← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testinv.py

  • Committer: Martin Pool
  • Date: 2005-10-06 04:09:55 UTC
  • mfrom: (1413)
  • mto: (1185.13.3)
  • mto: This revision was merged to the branch mainline in revision 1417.
  • Revision ID: mbp@sourcefrog.net-20051006040955-36f27e5a8d5c977b
[merge] from robert

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testinv.py
18
18
import os
19
19
 
20
20
from bzrlib.branch import Branch
 
21
from bzrlib.clone import copy_branch
 
22
import bzrlib.errors as errors
21
23
from bzrlib.diff import internal_diff
22
24
from bzrlib.inventory import Inventory, ROOT_ID
23
25
import bzrlib.inventory as inventory
24
 
from bzrlib.osutils import has_symlinks
 
26
from bzrlib.osutils import has_symlinks, rename
25
27
from bzrlib.selftest import TestCase, TestCaseInTempDir
26
28
 
27
29
 
65
67
        ## XXX
66
68
 
67
69
 
68
 
class TestInventoryEntry(TestCaseInTempDir):
 
70
class TestInventoryEntry(TestCase):
69
71
 
70
72
    def test_file_kind_character(self):
71
73
        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
219
221
                          output)
220
222
        self.assertEqual(output.getvalue(),
221
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