~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testinv.py

  • Committer: Aaron Bentley
  • Date: 2005-10-08 04:01:04 UTC
  • mfrom: (1423)
  • mto: (1185.25.1)
  • mto: This revision was merged to the branch mainline in revision 1425.
  • Revision ID: aaron.bentley@utoronto.ca-20051008040104-1c604843ae42de07
MergeĀ fromĀ Robert

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
                                  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