/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/bzrdir_implementations/test_bzrdir.py

  • Committer: John Arbash Meinel
  • Date: 2008-07-08 14:55:19 UTC
  • mfrom: (3530 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3532.
  • Revision ID: john@arbash-meinel.com-20080708145519-paqg4kjwbpgs2xmq
Merge bzr.dev 3530

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/bzrdir_implementations/test_bzrdir.py
36
36
    workingtree,
37
37
    )
38
38
from bzrlib.branch import Branch, needs_read_lock, needs_write_lock
39
 
from bzrlib.check import check
 
39
from bzrlib.check import check_branch
40
40
from bzrlib.errors import (FileExists,
41
41
                           NoSuchRevision,
42
42
                           NoSuchFile,
125
125
                    self.assertEqual(left_repo.get_revision(rev_id),
126
126
                        right_repo.get_revision(rev_id))
127
127
                # inventories
128
 
                left_inv_weave = left_repo.get_inventory_weave()
129
 
                right_inv_weave = right_repo.get_inventory_weave()
130
 
                self.assertEqual(set(left_inv_weave.versions()),
131
 
                    set(right_inv_weave.versions()))
 
128
                left_inv_weave = left_repo.inventories
 
129
                right_inv_weave = right_repo.inventories
 
130
                self.assertEqual(set(left_inv_weave.keys()),
 
131
                    set(right_inv_weave.keys()))
132
132
                # XXX: currently this does not handle indirectly referenced
133
133
                # inventories (e.g. where the inventory is a delta basis for
134
134
                # one that is fully present but that the revid for that
135
135
                # inventory is not yet present.)
136
 
                self.assertEqual(set(left_inv_weave.versions()), set(all_revs))
 
136
                self.assertEqual(set(left_inv_weave.keys()),
 
137
                    set(left_repo.revisions.keys()))
137
138
                left_trees = left_repo.revision_trees(all_revs)
138
139
                right_trees = right_repo.revision_trees(all_revs)
139
140
                for left_tree, right_tree in izip(left_trees, right_trees):
142
143
                text_index = left_repo._generate_text_key_index()
143
144
                self.assertEqual(text_index,
144
145
                    right_repo._generate_text_key_index())
 
146
                desired_files = []
145
147
                for file_id, revision_id in text_index.iterkeys():
146
 
                    left_weave = left_repo.weave_store.get_weave(
147
 
                        file_id, left_repo.get_transaction())
148
 
                    right_weave = right_repo.weave_store.get_weave(
149
 
                        file_id, right_repo.get_transaction())
150
 
                    self.assertEqual(
151
 
                        left_weave.get_text(revision_id),
152
 
                        right_weave.get_text(revision_id))
 
148
                    desired_files.append(
 
149
                        (file_id, revision_id, (file_id, revision_id)))
 
150
                left_texts = list(left_repo.iter_files_bytes(desired_files))
 
151
                right_texts = list(right_repo.iter_files_bytes(desired_files))
 
152
                left_texts.sort()
 
153
                right_texts.sort()
 
154
                self.assertEqual(left_texts, right_texts)
153
155
                # signatures
154
156
                for rev_id in all_revs:
155
157
                    try:
306
308
                                     './.bzr/merge-hashes',
307
309
                                     './.bzr/repository',
308
310
                                     ])
309
 
        self.assertRepositoryHasSameItems(tree.branch.repository, repo)
 
311
        self.assertRepositoryHasSameItems(tree.branch.repository,
 
312
            target.open_repository())
310
313
 
311
314
    def test_clone_bzrdir_repository_under_shared(self):
312
315
        tree = self.make_branch_and_tree('commit_tree')
537
540
            target.open_repository())
538
541
        target.open_workingtree().revert()
539
542
 
 
543
    def test_clone_on_transport_preserves_repo_format(self):
 
544
        if self.bzrdir_format == bzrdir.format_registry.make_bzrdir('default'):
 
545
            format = 'knit'
 
546
        else:
 
547
            format = None
 
548
        source_branch = self.make_branch('source', format=format)
 
549
        # Ensure no format data is cached
 
550
        a_dir = bzrlib.branch.Branch.open_from_transport(
 
551
            self.get_transport('source')).bzrdir
 
552
        target_transport = a_dir.root_transport.clone('..').clone('target')
 
553
        target_bzrdir = a_dir.clone_on_transport(target_transport)
 
554
        target_repo = target_bzrdir.open_repository()
 
555
        self.assertEqual(target_repo._format, source_branch.repository._format)
 
556
 
540
557
    def test_revert_inventory(self):
541
558
        tree = self.make_branch_and_tree('source')
542
559
        self.build_tree(['source/foo'])
1467
1484
            finally:
1468
1485
                pb.finished()
1469
1486
            # and it should pass 'check' now.
1470
 
            check(bzrdir.BzrDir.open(self.get_url('.')).open_branch(), False)
 
1487
            check_branch(bzrdir.BzrDir.open(self.get_url('.')).open_branch(),
 
1488
                         False)
1471
1489
 
1472
1490
    def test_format_description(self):
1473
1491
        dir = self.make_bzrdir('.')
1582
1600
                # its still held by the explicit lock we took, and the break
1583
1601
                # lock should not have touched it.
1584
1602
                repo = thisdir.open_repository()
1585
 
                orig_default = lockdir._DEFAULT_TIMEOUT_SECONDS
1586
 
                try:
1587
 
                    lockdir._DEFAULT_TIMEOUT_SECONDS = 1
1588
 
                    self.assertRaises(errors.LockContention, repo.lock_write)
1589
 
                finally:
1590
 
                    lockdir._DEFAULT_TIMEOUT_SECONDS = orig_default
 
1603
                self.assertRaises(errors.LockContention, repo.lock_write)
1591
1604
        finally:
1592
1605
            unused_repo.unlock()
1593
1606
        self.assertRaises(errors.LockBroken, master.unlock)