/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_inv.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-03-13 05:55:15 UTC
  • mfrom: (2348.1.2 mz.symlinks)
  • Revision ID: pqm@pqm.ubuntu.com-20070313055515-823e15af73d49270
(marienz,r=john,r=mbp) fix error committing merge with symlinks in dirstate

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_inv.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 cStringIO import StringIO
18
 
import os
19
 
import time
20
 
 
21
17
from bzrlib import errors, inventory, osutils
22
 
from bzrlib.branch import Branch
23
 
from bzrlib.diff import internal_diff
24
18
from bzrlib.inventory import (Inventory, ROOT_ID, InventoryFile,
25
19
    InventoryDirectory, InventoryEntry, TreeReference)
26
 
from bzrlib.osutils import (has_symlinks, rename, pathjoin, is_inside_any, 
 
20
from bzrlib.osutils import (pathjoin, is_inside_any, 
27
21
    is_inside_or_parent_of_any)
28
 
from bzrlib.tests import TestCase, TestCaseWithTransport
29
 
from bzrlib.transform import TreeTransform
30
 
from bzrlib.uncommit import uncommit
 
22
from bzrlib.tests import TestCase
31
23
 
32
24
 
33
25
class TestInventory(TestCase):
282
274
            osutils.normalized_filename = orig_normalized_filename
283
275
 
284
276
 
285
 
class TestEntryDiffing(TestCaseWithTransport):
286
 
 
287
 
    def setUp(self):
288
 
        super(TestEntryDiffing, self).setUp()
289
 
        self.wt = self.make_branch_and_tree('.')
290
 
        self.branch = self.wt.branch
291
 
        print >> open('file', 'wb'), 'foo'
292
 
        print >> open('binfile', 'wb'), 'foo'
293
 
        self.wt.add(['file'], ['fileid'])
294
 
        self.wt.add(['binfile'], ['binfileid'])
295
 
        if has_symlinks():
296
 
            os.symlink('target1', 'symlink')
297
 
            self.wt.add(['symlink'], ['linkid'])
298
 
        self.wt.commit('message_1', rev_id = '1')
299
 
        print >> open('file', 'wb'), 'bar'
300
 
        print >> open('binfile', 'wb'), 'x' * 1023 + '\x00'
301
 
        if has_symlinks():
302
 
            os.unlink('symlink')
303
 
            os.symlink('target2', 'symlink')
304
 
        self.tree_1 = self.branch.repository.revision_tree('1')
305
 
        self.inv_1 = self.branch.repository.get_inventory('1')
306
 
        self.file_1 = self.inv_1['fileid']
307
 
        self.file_1b = self.inv_1['binfileid']
308
 
        self.tree_2 = self.wt
309
 
        self.tree_2.lock_read()
310
 
        self.addCleanup(self.tree_2.unlock)
311
 
        self.inv_2 = self.tree_2.read_working_inventory()
312
 
        self.file_2 = self.inv_2['fileid']
313
 
        self.file_2b = self.inv_2['binfileid']
314
 
        if has_symlinks():
315
 
            self.link_1 = self.inv_1['linkid']
316
 
            self.link_2 = self.inv_2['linkid']
317
 
 
318
 
    def test_file_diff_deleted(self):
319
 
        output = StringIO()
320
 
        self.file_1.diff(internal_diff, 
321
 
                          "old_label", self.tree_1,
322
 
                          "/dev/null", None, None,
323
 
                          output)
324
 
        self.assertEqual(output.getvalue(), "--- old_label\n"
325
 
                                            "+++ /dev/null\n"
326
 
                                            "@@ -1,1 +0,0 @@\n"
327
 
                                            "-foo\n"
328
 
                                            "\n")
329
 
 
330
 
    def test_file_diff_added(self):
331
 
        output = StringIO()
332
 
        self.file_1.diff(internal_diff, 
333
 
                          "new_label", self.tree_1,
334
 
                          "/dev/null", None, None,
335
 
                          output, reverse=True)
336
 
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
337
 
                                            "+++ new_label\n"
338
 
                                            "@@ -0,0 +1,1 @@\n"
339
 
                                            "+foo\n"
340
 
                                            "\n")
341
 
 
342
 
    def test_file_diff_changed(self):
343
 
        output = StringIO()
344
 
        self.file_1.diff(internal_diff, 
345
 
                          "/dev/null", self.tree_1, 
346
 
                          "new_label", self.file_2, self.tree_2,
347
 
                          output)
348
 
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
349
 
                                            "+++ new_label\n"
350
 
                                            "@@ -1,1 +1,1 @@\n"
351
 
                                            "-foo\n"
352
 
                                            "+bar\n"
353
 
                                            "\n")
354
 
        
355
 
    def test_file_diff_binary(self):
356
 
        output = StringIO()
357
 
        self.file_1.diff(internal_diff, 
358
 
                          "/dev/null", self.tree_1, 
359
 
                          "new_label", self.file_2b, self.tree_2,
360
 
                          output)
361
 
        self.assertEqual(output.getvalue(), 
362
 
                         "Binary files /dev/null and new_label differ\n")
363
 
    def test_link_diff_deleted(self):
364
 
        if not has_symlinks():
365
 
            return
366
 
        output = StringIO()
367
 
        self.link_1.diff(internal_diff, 
368
 
                          "old_label", self.tree_1,
369
 
                          "/dev/null", None, None,
370
 
                          output)
371
 
        self.assertEqual(output.getvalue(),
372
 
                         "=== target was 'target1'\n")
373
 
 
374
 
    def test_link_diff_added(self):
375
 
        if not has_symlinks():
376
 
            return
377
 
        output = StringIO()
378
 
        self.link_1.diff(internal_diff, 
379
 
                          "new_label", self.tree_1,
380
 
                          "/dev/null", None, None,
381
 
                          output, reverse=True)
382
 
        self.assertEqual(output.getvalue(),
383
 
                         "=== target is 'target1'\n")
384
 
 
385
 
    def test_link_diff_changed(self):
386
 
        if not has_symlinks():
387
 
            return
388
 
        output = StringIO()
389
 
        self.link_1.diff(internal_diff, 
390
 
                          "/dev/null", self.tree_1, 
391
 
                          "new_label", self.link_2, self.tree_2,
392
 
                          output)
393
 
        self.assertEqual(output.getvalue(),
394
 
                         "=== target changed 'target1' => 'target2'\n")
395
 
 
396
 
 
397
 
class TestSnapshot(TestCaseWithTransport):
398
 
 
399
 
    def setUp(self):
400
 
        # for full testing we'll need a branch
401
 
        # with a subdir to test parent changes.
402
 
        # and a file, link and dir under that.
403
 
        # but right now I only need one attribute
404
 
        # to change, and then test merge patterns
405
 
        # with fake parent entries.
406
 
        super(TestSnapshot, self).setUp()
407
 
        self.wt = self.make_branch_and_tree('.')
408
 
        self.branch = self.wt.branch
409
 
        self.build_tree(['subdir/', 'subdir/file'], line_endings='binary')
410
 
        self.wt.add(['subdir', 'subdir/file'],
411
 
                                       ['dirid', 'fileid'])
412
 
        if has_symlinks():
413
 
            pass
414
 
        self.wt.commit('message_1', rev_id = '1')
415
 
        self.tree_1 = self.branch.repository.revision_tree('1')
416
 
        self.inv_1 = self.branch.repository.get_inventory('1')
417
 
        self.file_1 = self.inv_1['fileid']
418
 
        self.wt.lock_write()
419
 
        self.addCleanup(self.wt.unlock)
420
 
        self.file_active = self.wt.inventory['fileid']
421
 
        self.builder = self.branch.get_commit_builder([], timestamp=time.time(), revision_id='2')
422
 
 
423
 
    def test_snapshot_new_revision(self):
424
 
        # This tests that a simple commit with no parents makes a new
425
 
        # revision value in the inventory entry
426
 
        self.file_active.snapshot('2', 'subdir/file', {}, self.wt, self.builder)
427
 
        # expected outcome - file_1 has a revision id of '2', and we can get
428
 
        # its text of 'file contents' out of the weave.
429
 
        self.assertEqual(self.file_1.revision, '1')
430
 
        self.assertEqual(self.file_active.revision, '2')
431
 
        # this should be a separate test probably, but lets check it once..
432
 
        lines = self.branch.repository.weave_store.get_weave(
433
 
            'fileid', 
434
 
            self.branch.get_transaction()).get_lines('2')
435
 
        self.assertEqual(lines, ['contents of subdir/file\n'])
436
 
 
437
 
    def test_snapshot_unchanged(self):
438
 
        #This tests that a simple commit does not make a new entry for
439
 
        # an unchanged inventory entry
440
 
        self.file_active.snapshot('2', 'subdir/file', {'1':self.file_1},
441
 
                                  self.wt, self.builder)
442
 
        self.assertEqual(self.file_1.revision, '1')
443
 
        self.assertEqual(self.file_active.revision, '1')
444
 
        vf = self.branch.repository.weave_store.get_weave(
445
 
            'fileid', 
446
 
            self.branch.repository.get_transaction())
447
 
        self.assertRaises(errors.RevisionNotPresent,
448
 
                          vf.get_lines,
449
 
                          '2')
450
 
 
451
 
    def test_snapshot_merge_identical_different_revid(self):
452
 
        # This tests that a commit with two identical parents, one of which has
453
 
        # a different revision id, results in a new revision id in the entry.
454
 
        # 1->other, commit a merge of other against 1, results in 2.
455
 
        other_ie = inventory.InventoryFile('fileid', 'newname', self.file_1.parent_id)
456
 
        other_ie = inventory.InventoryFile('fileid', 'file', self.file_1.parent_id)
457
 
        other_ie.revision = '1'
458
 
        other_ie.text_sha1 = self.file_1.text_sha1
459
 
        other_ie.text_size = self.file_1.text_size
460
 
        self.assertEqual(self.file_1, other_ie)
461
 
        other_ie.revision = 'other'
462
 
        self.assertNotEqual(self.file_1, other_ie)
463
 
        versionfile = self.branch.repository.weave_store.get_weave(
464
 
            'fileid', self.branch.repository.get_transaction())
465
 
        versionfile.clone_text('other', '1', ['1'])
466
 
        self.file_active.snapshot('2', 'subdir/file', 
467
 
                                  {'1':self.file_1, 'other':other_ie},
468
 
                                  self.wt, self.builder)
469
 
        self.assertEqual(self.file_active.revision, '2')
470
 
 
471
 
    def test_snapshot_changed(self):
472
 
        # This tests that a commit with one different parent results in a new
473
 
        # revision id in the entry.
474
 
        self.wt.rename_one('subdir/file', 'subdir/newname')
475
 
        self.file_active = self.wt.inventory['fileid']
476
 
        self.file_active.snapshot('2', 'subdir/newname', {'1':self.file_1}, 
477
 
                                  self.wt, self.builder)
478
 
        # expected outcome - file_1 has a revision id of '2'
479
 
        self.assertEqual(self.file_active.revision, '2')
480
 
 
481
 
 
482
 
class TestPreviousHeads(TestCaseWithTransport):
483
 
 
484
 
    def setUp(self):
485
 
        # we want several inventories, that respectively
486
 
        # give use the following scenarios:
487
 
        # A) fileid not in any inventory (A),
488
 
        # B) fileid present in one inventory (B) and (A,B)
489
 
        # C) fileid present in two inventories, and they
490
 
        #   are not mutual descendents (B, C)
491
 
        # D) fileid present in two inventories and one is
492
 
        #   a descendent of the other. (B, D)
493
 
        super(TestPreviousHeads, self).setUp()
494
 
        self.wt = self.make_branch_and_tree('.')
495
 
        self.branch = self.wt.branch
496
 
        self.build_tree(['file'])
497
 
        self.wt.commit('new branch', allow_pointless=True, rev_id='A')
498
 
        self.inv_A = self.branch.repository.get_inventory('A')
499
 
        self.wt.add(['file'], ['fileid'])
500
 
        self.wt.commit('add file', rev_id='B')
501
 
        self.inv_B = self.branch.repository.get_inventory('B')
502
 
        uncommit(self.branch, tree=self.wt)
503
 
        self.assertEqual(self.branch.revision_history(), ['A'])
504
 
        self.wt.commit('another add of file', rev_id='C')
505
 
        self.inv_C = self.branch.repository.get_inventory('C')
506
 
        self.wt.add_parent_tree_id('B')
507
 
        self.wt.commit('merge in B', rev_id='D')
508
 
        self.inv_D = self.branch.repository.get_inventory('D')
509
 
        self.wt.lock_read()
510
 
        self.addCleanup(self.wt.unlock)
511
 
        self.file_active = self.wt.inventory['fileid']
512
 
        self.weave = self.branch.repository.weave_store.get_weave('fileid',
513
 
            self.branch.repository.get_transaction())
514
 
        
515
 
    def get_previous_heads(self, inventories):
516
 
        return self.file_active.find_previous_heads(
517
 
            inventories, 
518
 
            self.branch.repository.weave_store,
519
 
            self.branch.repository.get_transaction())
520
 
        
521
 
    def test_fileid_in_no_inventory(self):
522
 
        self.assertEqual({}, self.get_previous_heads([self.inv_A]))
523
 
 
524
 
    def test_fileid_in_one_inventory(self):
525
 
        self.assertEqual({'B':self.inv_B['fileid']},
526
 
                         self.get_previous_heads([self.inv_B]))
527
 
        self.assertEqual({'B':self.inv_B['fileid']},
528
 
                         self.get_previous_heads([self.inv_A, self.inv_B]))
529
 
        self.assertEqual({'B':self.inv_B['fileid']},
530
 
                         self.get_previous_heads([self.inv_B, self.inv_A]))
531
 
 
532
 
    def test_fileid_in_two_inventories_gives_both_entries(self):
533
 
        self.assertEqual({'B':self.inv_B['fileid'],
534
 
                          'C':self.inv_C['fileid']},
535
 
                          self.get_previous_heads([self.inv_B, self.inv_C]))
536
 
        self.assertEqual({'B':self.inv_B['fileid'],
537
 
                          'C':self.inv_C['fileid']},
538
 
                          self.get_previous_heads([self.inv_C, self.inv_B]))
539
 
 
540
 
    def test_fileid_in_two_inventories_already_merged_gives_head(self):
541
 
        self.assertEqual({'D':self.inv_D['fileid']},
542
 
                         self.get_previous_heads([self.inv_B, self.inv_D]))
543
 
        self.assertEqual({'D':self.inv_D['fileid']},
544
 
                         self.get_previous_heads([self.inv_D, self.inv_B]))
545
 
 
546
 
    # TODO: test two inventories with the same file revision 
547
 
 
548
 
 
549
277
class TestDescribeChanges(TestCase):
550
278
 
551
279
    def test_describe_change(self):
604
332
        self.assertEqual(expected_change, change)
605
333
 
606
334
 
607
 
class TestRevert(TestCaseWithTransport):
608
 
 
609
 
    def test_dangling_id(self):
610
 
        wt = self.make_branch_and_tree('b1')
611
 
        wt.lock_tree_write()
612
 
        self.addCleanup(wt.unlock)
613
 
        self.assertEqual(len(wt.inventory), 1)
614
 
        open('b1/a', 'wb').write('a test\n')
615
 
        wt.add('a')
616
 
        self.assertEqual(len(wt.inventory), 2)
617
 
        wt.flush() # workaround revert doing wt._write_inventory for now.
618
 
        os.unlink('b1/a')
619
 
        wt.revert([])
620
 
        self.assertEqual(len(wt.inventory), 1)
621
 
 
622
 
 
623
335
class TestIsRoot(TestCase):
624
336
    """Ensure our root-checking code is accurate."""
625
337