← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_bzrdir.py

  • Committer: Martin Packman
  • Date: 2012-01-05 10:37:58 UTC
  • mto: This revision was merged to the branch mainline in revision 6427.
  • Revision ID: martin.packman@canonical.com-20120105103758-wzftnmsip5iv9n2g
Revert addition of get_message_encoding function

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bzrdir.py
26
26
from bzrlib import (
27
27
    branch,
28
28
    bzrdir,
 
29
    config,
29
30
    controldir,
30
31
    errors,
31
32
    help_topics,
252
253
    def open(self, transport, _found=None):
253
254
        return "opened branch."
254
255
 
 
256
    @classmethod
 
257
    def from_string(cls, format_string):
 
258
        return cls()
 
259
 
255
260
 
256
261
class BzrDirFormatTest1(bzrdir.BzrDirMetaFormat1):
257
262
 
285
290
        self.build_tree(["foo/", "bar/"], transport=t)
286
291
        def check_format(format, url):
287
292
            format.initialize(url)
288
 
            t = _mod_transport.get_transport(url)
 
293
            t = _mod_transport.get_transport_from_path(url)
289
294
            found_format = bzrdir.BzrDirFormat.find_format(t)
290
295
            self.assertIsInstance(found_format, format.__class__)
291
296
        check_format(BzrDirFormatTest1(), "foo")
294
299
    def test_find_format_nothing_there(self):
295
300
        self.assertRaises(NotBranchError,
296
301
                          bzrdir.BzrDirFormat.find_format,
297
 
                          _mod_transport.get_transport('.'))
 
302
                          _mod_transport.get_transport_from_path('.'))
298
303
 
299
304
    def test_find_format_unknown_format(self):
300
305
        t = self.get_transport()
302
307
        t.put_bytes('.bzr/branch-format', '')
303
308
        self.assertRaises(UnknownFormatError,
304
309
                          bzrdir.BzrDirFormat.find_format,
305
 
                          _mod_transport.get_transport('.'))
 
310
                          _mod_transport.get_transport_from_path('.'))
306
311
 
307
312
    def test_register_unregister_format(self):
308
313
        format = SampleBzrDirFormat()
316
321
        # which bzrdir.open_containing will refuse (not supported)
317
322
        self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)
318
323
        # but open_downlevel will work
319
 
        t = _mod_transport.get_transport(url)
 
324
        t = _mod_transport.get_transport_from_url(url)
320
325
        self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))
321
326
        # unregister the format
322
327
        bzrdir.BzrProber.formats.remove(format.get_format_string())
512
517
        # Clone source into directory
513
518
        target = source_bzrdir.clone(self.get_url('parent/target'))
514
519
 
 
520
    def test_format_initialize_on_transport_ex_stacked_on(self):
 
521
        # trunk is a stackable format.  Note that its in the same server area
 
522
        # which is what launchpad does, but not sufficient to exercise the
 
523
        # general case.
 
524
        trunk = self.make_branch('trunk', format='1.9')
 
525
        t = self.get_transport('stacked')
 
526
        old_fmt = bzrdir.format_registry.make_bzrdir('pack-0.92')
 
527
        repo_name = old_fmt.repository_format.network_name()
 
528
        # Should end up with a 1.9 format (stackable)
 
529
        repo, control, require_stacking, repo_policy = \
 
530
            old_fmt.initialize_on_transport_ex(t,
 
531
                    repo_format_name=repo_name, stacked_on='../trunk',
 
532
                    stack_on_pwd=t.base)
 
533
        if repo is not None:
 
534
            # Repositories are open write-locked
 
535
            self.assertTrue(repo.is_write_locked())
 
536
            self.addCleanup(repo.unlock)
 
537
        else:
 
538
            repo = control.open_repository()
 
539
        self.assertIsInstance(control, bzrdir.BzrDir)
 
540
        opened = bzrdir.BzrDir.open(t.base)
 
541
        if not isinstance(old_fmt, remote.RemoteBzrDirFormat):
 
542
            self.assertEqual(control._format.network_name(),
 
543
                old_fmt.network_name())
 
544
            self.assertEqual(control._format.network_name(),
 
545
                opened._format.network_name())
 
546
        self.assertEqual(control.__class__, opened.__class__)
 
547
        self.assertLength(1, repo._fallback_repositories)
 
548
 
515
549
    def test_sprout_obeys_stacking_policy(self):
516
550
        child_branch, new_child_transport = self.prepare_default_stacking()
517
551
        new_child = child_branch.bzrdir.sprout(new_child_transport.base)
710
744
    def test_open_containing_from_transport(self):
711
745
        self.assertRaises(NotBranchError,
712
746
            bzrdir.BzrDir.open_containing_from_transport,
713
 
            _mod_transport.get_transport(self.get_readonly_url('')))
 
747
            _mod_transport.get_transport_from_url(self.get_readonly_url('')))
714
748
        self.assertRaises(NotBranchError,
715
749
            bzrdir.BzrDir.open_containing_from_transport,
716
 
            _mod_transport.get_transport(self.get_readonly_url('g/p/q')))
 
750
            _mod_transport.get_transport_from_url(
 
751
                self.get_readonly_url('g/p/q')))
717
752
        control = bzrdir.BzrDir.create(self.get_url())
718
753
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
719
 
            _mod_transport.get_transport(self.get_readonly_url('')))
 
754
            _mod_transport.get_transport_from_url(
 
755
                self.get_readonly_url('')))
720
756
        self.assertEqual('', relpath)
721
757
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
722
 
            _mod_transport.get_transport(self.get_readonly_url('g/p/q')))
 
758
            _mod_transport.get_transport_from_url(
 
759
                self.get_readonly_url('g/p/q')))
723
760
        self.assertEqual('g/p/q', relpath)
724
761
 
725
762
    def test_open_containing_tree_or_branch(self):
898
935
        def evaluate(bzrdir):
899
936
            try:
900
937
                repo = bzrdir.open_repository()
901
 
            except NoRepositoryPresent:
 
938
            except errors.NoRepositoryPresent:
902
939
                return True, bzrdir.root_transport.base
903
940
            else:
904
941
                return False, bzrdir.root_transport.base
1208
1245
 
1209
1246
    def __init__(self, *args, **kwargs):
1210
1247
        super(_TestBzrDir, self).__init__(*args, **kwargs)
1211
 
        self.test_branch = _TestBranch()
 
1248
        self.test_branch = _TestBranch(self.transport)
1212
1249
        self.test_branch.repository = self.create_repository()
1213
1250
 
1214
 
    def open_branch(self, unsupported=False):
 
1251
    def open_branch(self, unsupported=False, possible_transports=None):
1215
1252
        return self.test_branch
1216
1253
 
1217
1254
    def cloning_metadir(self, require_stacking=False):
1225
1262
class _TestBranch(bzrlib.branch.Branch):
1226
1263
    """Test Branch implementation for TestBzrDirSprout."""
1227
1264
 
1228
 
    def __init__(self, *args, **kwargs):
 
1265
    def __init__(self, transport, *args, **kwargs):
1229
1266
        self._format = _TestBranchFormat()
 
1267
        self._transport = transport
 
1268
        self.base = transport.base
1230
1269
        super(_TestBranch, self).__init__(*args, **kwargs)
1231
1270
        self.calls = []
1232
1271
        self._parent = None
1233
1272
 
1234
1273
    def sprout(self, *args, **kwargs):
1235
1274
        self.calls.append('sprout')
1236
 
        return _TestBranch()
 
1275
        return _TestBranch(self._transport)
1237
1276
 
1238
1277
    def copy_content_into(self, destination, revision_id=None):
1239
1278
        self.calls.append('copy_content_into')
1244
1283
    def get_parent(self):
1245
1284
        return self._parent
1246
1285
 
 
1286
    def _get_config(self):
 
1287
        return config.TransportConfig(self._transport, 'branch.conf')
 
1288
 
1247
1289
    def set_parent(self, parent):
1248
1290
        self._parent = parent
1249
1291
 
1314
1356
        self.assertEqual('fail', err._preformatted_string)
1315
1357
 
1316
1358
    def test_post_repo_init(self):
1317
 
        from bzrlib.bzrdir import RepoInitHookParams
 
1359
        from bzrlib.controldir import RepoInitHookParams
1318
1360
        calls = []
1319
1361
        bzrdir.BzrDir.hooks.install_named_hook('post_repo_init',
1320
1362
            calls.append, None)
1359
1401
        self._transport.put_bytes("a.~1~", "some content")
1360
1402
        self.assertEqual("a.~2~", self._bzrdir._available_backup_name("a"))
1361
1403
 
 
1404
 
 
1405
class TestMeta1DirColoFormat(TestCaseWithTransport):
 
1406
    """Tests specific to the meta1 dir with colocated branches format."""
 
1407
 
 
1408
    def test_supports_colo(self):
 
1409
        format = bzrdir.BzrDirMetaFormat1Colo()
 
1410
        self.assertTrue(format.colocated_branches)
 
1411
 
 
1412
    def test_upgrade_from_2a(self):
 
1413
        tree = self.make_branch_and_tree('.', format='2a')
 
1414
        format = bzrdir.BzrDirMetaFormat1Colo()
 
1415
        self.assertTrue(tree.bzrdir.needs_format_conversion(format))
 
1416
        converter = tree.bzrdir._format.get_converter(format)
 
1417
        result = converter.convert(tree.bzrdir, None)
 
1418
        self.assertIsInstance(result._format, bzrdir.BzrDirMetaFormat1Colo)
 
1419
        self.assertFalse(result.needs_format_conversion(format))
 
1420
 
 
1421
    def test_downgrade_to_2a(self):
 
1422
        tree = self.make_branch_and_tree('.', format='development-colo')
 
1423
        format = bzrdir.BzrDirMetaFormat1()
 
1424
        self.assertTrue(tree.bzrdir.needs_format_conversion(format))
 
1425
        converter = tree.bzrdir._format.get_converter(format)
 
1426
        result = converter.convert(tree.bzrdir, None)
 
1427
        self.assertIsInstance(result._format, bzrdir.BzrDirMetaFormat1)
 
1428
        self.assertFalse(result.needs_format_conversion(format))
 
1429
 
 
1430
    def test_downgrade_to_2a_too_many_branches(self):
 
1431
        tree = self.make_branch_and_tree('.', format='development-colo')
 
1432
        tree.bzrdir.create_branch(name="another-colocated-branch")
 
1433
        converter = tree.bzrdir._format.get_converter(
 
1434
            bzrdir.BzrDirMetaFormat1())
 
1435
        self.assertRaises(errors.BzrError, converter.convert, tree.bzrdir,
 
1436
            None)
 
1437