~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-04 04:49:21 UTC
  • Revision ID: robertc@robertcollins.net-20051004044921-45fd2dc3f70abe59
remove debug print statement

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
23
21
from bzrlib.diff import internal_diff
24
22
from bzrlib.inventory import Inventory, ROOT_ID
25
23
import bzrlib.inventory as inventory
26
 
from bzrlib.osutils import has_symlinks, rename
 
24
from bzrlib.osutils import has_symlinks
27
25
from bzrlib.selftest import TestCase, TestCaseInTempDir
28
26
 
29
27
 
67
65
        ## XXX
68
66
 
69
67
 
70
 
class TestInventoryEntry(TestCase):
 
68
class TestInventoryEntry(TestCaseInTempDir):
71
69
 
72
70
    def test_file_kind_character(self):
73
71
        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
221
219
                          output)
222
220
        self.assertEqual(output.getvalue(),
223
221
                         "=== 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