/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_remote.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-09-23 06:54:14 UTC
  • mfrom: (4695.5.9 remove-logging)
  • Revision ID: pqm@pqm.ubuntu.com-20090923065414-vue8c7speunw9wbq
(mbp) deprecate trace.info, error, show_error

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
27
27
from cStringIO import StringIO
28
28
 
29
29
from bzrlib import (
30
 
    branch,
31
30
    bzrdir,
32
31
    config,
33
32
    errors,
37
36
    pack,
38
37
    remote,
39
38
    repository,
 
39
    smart,
40
40
    tests,
41
41
    treebuilder,
42
42
    urlutils,
54
54
    )
55
55
from bzrlib.repofmt import groupcompress_repo, pack_repo
56
56
from bzrlib.revision import NULL_REVISION
57
 
from bzrlib.smart import medium
 
57
from bzrlib.smart import server, medium
58
58
from bzrlib.smart.client import _SmartClient
59
59
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
60
60
from bzrlib.tests import (
61
61
    condition_isinstance,
62
62
    split_suite_by_condition,
63
63
    multiply_tests,
64
 
    test_server,
 
64
    KnownFailure,
65
65
    )
66
 
from bzrlib.transport import get_transport
 
66
from bzrlib.transport import get_transport, http
67
67
from bzrlib.transport.memory import MemoryTransport
68
68
from bzrlib.transport.remote import (
69
69
    RemoteTransport,
76
76
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
77
77
    smart_server_version_scenarios = [
78
78
        ('HPSS-v2',
79
 
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
 
79
            {'transport_server': server.SmartTCPServer_for_testing_v2_only}),
80
80
        ('HPSS-v3',
81
 
         {'transport_server': test_server.SmartTCPServer_for_testing})]
 
81
            {'transport_server': server.SmartTCPServer_for_testing})]
82
82
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
83
83
 
84
84
 
135
135
        b = BzrDir.open_from_transport(self.transport).open_branch()
136
136
        self.assertStartsWith(str(b), 'RemoteBranch(')
137
137
 
138
 
    def test_remote_bzrdir_repr(self):
139
 
        b = BzrDir.open_from_transport(self.transport)
140
 
        self.assertStartsWith(str(b), 'RemoteBzrDir(')
141
 
 
142
138
    def test_remote_branch_format_supports_stacking(self):
143
139
        t = self.transport
144
140
        self.make_branch('unstackable', format='pack-0.92')
418
414
        # Calling _remember_remote_is_before again with a lower value works.
419
415
        client_medium._remember_remote_is_before((1, 5))
420
416
        self.assertTrue(client_medium._is_remote_before((1, 5)))
421
 
        # If you call _remember_remote_is_before with a higher value it logs a
422
 
        # warning, and continues to remember the lower value.
423
 
        self.assertNotContainsRe(self.get_log(), '_remember_remote_is_before')
424
 
        client_medium._remember_remote_is_before((1, 9))
425
 
        self.assertContainsRe(self.get_log(), '_remember_remote_is_before')
426
 
        self.assertTrue(client_medium._is_remote_before((1, 5)))
 
417
        # You cannot call _remember_remote_is_before with a larger value.
 
418
        self.assertRaises(
 
419
            AssertionError, client_medium._remember_remote_is_before, (1, 9))
427
420
 
428
421
 
429
422
class TestBzrDirCloningMetaDir(TestRemote):
448
441
            'BzrDir.cloning_metadir', ('quack/', 'False'),
449
442
            'error', ('BranchReference',)),
450
443
        client.add_expected_call(
451
 
            'BzrDir.open_branchV3', ('quack/',),
 
444
            'BzrDir.open_branchV2', ('quack/',),
452
445
            'success', ('ref', self.get_url('referenced'))),
453
446
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
454
447
            _client=client)
481
474
        self.assertFinished(client)
482
475
 
483
476
 
484
 
class TestBzrDirOpen(TestRemote):
485
 
 
486
 
    def make_fake_client_and_transport(self, path='quack'):
487
 
        transport = MemoryTransport()
488
 
        transport.mkdir(path)
489
 
        transport = transport.clone(path)
490
 
        client = FakeClient(transport.base)
491
 
        return client, transport
492
 
 
493
 
    def test_absent(self):
494
 
        client, transport = self.make_fake_client_and_transport()
495
 
        client.add_expected_call(
496
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
497
 
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
498
 
                remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
499
 
        self.assertFinished(client)
500
 
 
501
 
    def test_present_without_workingtree(self):
502
 
        client, transport = self.make_fake_client_and_transport()
503
 
        client.add_expected_call(
504
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
505
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
506
 
            _client=client, _force_probe=True)
507
 
        self.assertIsInstance(bd, RemoteBzrDir)
508
 
        self.assertFalse(bd.has_workingtree())
509
 
        self.assertRaises(errors.NoWorkingTree, bd.open_workingtree)
510
 
        self.assertFinished(client)
511
 
 
512
 
    def test_present_with_workingtree(self):
513
 
        client, transport = self.make_fake_client_and_transport()
514
 
        client.add_expected_call(
515
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
516
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
517
 
            _client=client, _force_probe=True)
518
 
        self.assertIsInstance(bd, RemoteBzrDir)
519
 
        self.assertTrue(bd.has_workingtree())
520
 
        self.assertRaises(errors.NotLocalUrl, bd.open_workingtree)
521
 
        self.assertFinished(client)
522
 
 
523
 
    def test_backwards_compat(self):
524
 
        client, transport = self.make_fake_client_and_transport()
525
 
        client.add_expected_call(
526
 
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
527
 
        client.add_expected_call(
528
 
            'BzrDir.open', ('quack/',), 'success', ('yes',))
529
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
530
 
            _client=client, _force_probe=True)
531
 
        self.assertIsInstance(bd, RemoteBzrDir)
532
 
        self.assertFinished(client)
533
 
 
534
 
    def test_backwards_compat_hpss_v2(self):
535
 
        client, transport = self.make_fake_client_and_transport()
536
 
        # Monkey-patch fake client to simulate real-world behaviour with v2
537
 
        # server: upon first RPC call detect the protocol version, and because
538
 
        # the version is 2 also do _remember_remote_is_before((1, 6)) before
539
 
        # continuing with the RPC.
540
 
        orig_check_call = client._check_call
541
 
        def check_call(method, args):
542
 
            client._medium._protocol_version = 2
543
 
            client._medium._remember_remote_is_before((1, 6))
544
 
            client._check_call = orig_check_call
545
 
            client._check_call(method, args)
546
 
        client._check_call = check_call
547
 
        client.add_expected_call(
548
 
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
549
 
        client.add_expected_call(
550
 
            'BzrDir.open', ('quack/',), 'success', ('yes',))
551
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
552
 
            _client=client, _force_probe=True)
553
 
        self.assertIsInstance(bd, RemoteBzrDir)
554
 
        self.assertFinished(client)
555
 
 
556
 
 
557
477
class TestBzrDirOpenBranch(TestRemote):
558
478
 
559
479
    def test_backwards_compat(self):
561
481
        self.make_branch('.')
562
482
        a_dir = BzrDir.open(self.get_url('.'))
563
483
        self.reset_smart_call_log()
564
 
        verb = 'BzrDir.open_branchV3'
 
484
        verb = 'BzrDir.open_branchV2'
565
485
        self.disable_verb(verb)
566
486
        format = a_dir.open_branch()
567
487
        call_count = len([call for call in self.hpss_calls if
577
497
        transport = transport.clone('quack')
578
498
        client = FakeClient(transport.base)
579
499
        client.add_expected_call(
580
 
            'BzrDir.open_branchV3', ('quack/',),
 
500
            'BzrDir.open_branchV2', ('quack/',),
581
501
            'success', ('branch', branch_network_name))
582
502
        client.add_expected_call(
583
503
            'BzrDir.find_repositoryV3', ('quack/',),
602
522
            _client=client)
603
523
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
604
524
        self.assertEqual(
605
 
            [('call', 'BzrDir.open_branchV3', ('quack/',))],
 
525
            [('call', 'BzrDir.open_branchV2', ('quack/',))],
606
526
            client._calls)
607
527
 
608
528
    def test__get_tree_branch(self):
632
552
        network_name = reference_format.network_name()
633
553
        branch_network_name = self.get_branch_format().network_name()
634
554
        client.add_expected_call(
635
 
            'BzrDir.open_branchV3', ('~hello/',),
 
555
            'BzrDir.open_branchV2', ('~hello/',),
636
556
            'success', ('branch', branch_network_name))
637
557
        client.add_expected_call(
638
558
            'BzrDir.find_repositoryV3', ('~hello/',),
1220
1140
        client = FakeClient(self.get_url())
1221
1141
        branch_network_name = self.get_branch_format().network_name()
1222
1142
        client.add_expected_call(
1223
 
            'BzrDir.open_branchV3', ('stacked/',),
 
1143
            'BzrDir.open_branchV2', ('stacked/',),
1224
1144
            'success', ('branch', branch_network_name))
1225
1145
        client.add_expected_call(
1226
1146
            'BzrDir.find_repositoryV3', ('stacked/',),
1248
1168
            len(branch.repository._real_repository._fallback_repositories))
1249
1169
 
1250
1170
    def test_get_stacked_on_real_branch(self):
1251
 
        base_branch = self.make_branch('base')
1252
 
        stacked_branch = self.make_branch('stacked')
 
1171
        base_branch = self.make_branch('base', format='1.6')
 
1172
        stacked_branch = self.make_branch('stacked', format='1.6')
1253
1173
        stacked_branch.set_stacked_on_url('../base')
1254
1174
        reference_format = self.get_repo_format()
1255
1175
        network_name = reference_format.network_name()
1256
1176
        client = FakeClient(self.get_url())
1257
1177
        branch_network_name = self.get_branch_format().network_name()
1258
1178
        client.add_expected_call(
1259
 
            'BzrDir.open_branchV3', ('stacked/',),
 
1179
            'BzrDir.open_branchV2', ('stacked/',),
1260
1180
            'success', ('branch', branch_network_name))
1261
1181
        client.add_expected_call(
1262
1182
            'BzrDir.find_repositoryV3', ('stacked/',),
1263
 
            'success', ('ok', '', 'yes', 'no', 'yes', network_name))
 
1183
            'success', ('ok', '', 'no', 'no', 'yes', network_name))
1264
1184
        # called twice, once from constructor and then again by us
1265
1185
        client.add_expected_call(
1266
1186
            'Branch.get_stacked_on_url', ('stacked/',),
1811
1731
        return repo, client
1812
1732
 
1813
1733
 
1814
 
def remoted_description(format):
1815
 
    return 'Remote: ' + format.get_format_description()
1816
 
 
1817
 
 
1818
 
class TestBranchFormat(tests.TestCase):
1819
 
 
1820
 
    def test_get_format_description(self):
1821
 
        remote_format = RemoteBranchFormat()
1822
 
        real_format = branch.BranchFormat.get_default_format()
1823
 
        remote_format._network_name = real_format.network_name()
1824
 
        self.assertEqual(remoted_description(real_format),
1825
 
            remote_format.get_format_description())
1826
 
 
1827
 
 
1828
1734
class TestRepositoryFormat(TestRemoteRepository):
1829
1735
 
1830
1736
    def test_fast_delta(self):
1837
1743
        false_format._network_name = false_name
1838
1744
        self.assertEqual(False, false_format.fast_deltas)
1839
1745
 
1840
 
    def test_get_format_description(self):
1841
 
        remote_repo_format = RemoteRepositoryFormat()
1842
 
        real_format = repository.RepositoryFormat.get_default_format()
1843
 
        remote_repo_format._network_name = real_format.network_name()
1844
 
        self.assertEqual(remoted_description(real_format),
1845
 
            remote_repo_format.get_format_description())
1846
 
 
1847
1746
 
1848
1747
class TestRepositoryGatherStats(TestRemoteRepository):
1849
1748
 
2034
1933
        self.assertLength(1, self.hpss_calls)
2035
1934
 
2036
1935
    def disableExtraResults(self):
2037
 
        self.overrideAttr(SmartServerRepositoryGetParentMap,
2038
 
                          'no_extra_results', True)
 
1936
        old_flag = SmartServerRepositoryGetParentMap.no_extra_results
 
1937
        SmartServerRepositoryGetParentMap.no_extra_results = True
 
1938
        def reset_values():
 
1939
            SmartServerRepositoryGetParentMap.no_extra_results = old_flag
 
1940
        self.addCleanup(reset_values)
2039
1941
 
2040
1942
    def test_null_cached_missing_and_stop_key(self):
2041
1943
        self.setup_smart_server_with_call_log()
2100
2002
 
2101
2003
    def test_allows_new_revisions(self):
2102
2004
        """get_parent_map's results can be updated by commit."""
2103
 
        smart_server = test_server.SmartTCPServer_for_testing()
 
2005
        smart_server = server.SmartTCPServer_for_testing()
2104
2006
        self.start_server(smart_server)
2105
2007
        self.make_branch('branch')
2106
2008
        branch = Branch.open(smart_server.get_url() + '/branch')
2216
2118
        """
2217
2119
        # Make a repo with a fallback repo, both using a FakeClient.
2218
2120
        format = remote.response_tuple_to_repo_format(
2219
 
            ('yes', 'no', 'yes', self.get_repo_format().network_name()))
 
2121
            ('yes', 'no', 'yes', 'fake-network-name'))
2220
2122
        repo, client = self.setup_fake_client_and_repository('quack')
2221
2123
        repo._format = format
2222
2124
        fallback_repo, ignored = self.setup_fake_client_and_repository(
2223
2125
            'fallback')
2224
2126
        fallback_repo._client = client
2225
 
        fallback_repo._format = format
2226
2127
        repo.add_fallback_repository(fallback_repo)
2227
2128
        # First the client should ask the primary repo
2228
2129
        client.add_expected_call(
2249
2150
            repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
2250
2151
        self.assertFinished(client)
2251
2152
 
2252
 
    def test_branch_fallback_locking(self):
2253
 
        """RemoteBranch.get_rev_id takes a read lock, and tries to call the
2254
 
        get_rev_id_for_revno verb.  If the verb is unknown the VFS fallback
2255
 
        will be invoked, which will fail if the repo is unlocked.
2256
 
        """
2257
 
        self.setup_smart_server_with_call_log()
2258
 
        tree = self.make_branch_and_memory_tree('.')
2259
 
        tree.lock_write()
2260
 
        rev1 = tree.commit('First')
2261
 
        rev2 = tree.commit('Second')
2262
 
        tree.unlock()
2263
 
        branch = tree.branch
2264
 
        self.assertFalse(branch.is_locked())
2265
 
        self.reset_smart_call_log()
2266
 
        verb = 'Repository.get_rev_id_for_revno'
2267
 
        self.disable_verb(verb)
2268
 
        self.assertEqual(rev1, branch.get_rev_id(1))
2269
 
        self.assertLength(1, [call for call in self.hpss_calls if
2270
 
                              call.call.method == verb])
2271
 
 
2272
2153
 
2273
2154
class TestRepositoryIsShared(TestRemoteRepository):
2274
2155
 
2649
2530
    """RemoteRepository.copy_content_into optimizations"""
2650
2531
 
2651
2532
    def test_copy_content_remote_to_local(self):
2652
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2533
        self.transport_server = server.SmartTCPServer_for_testing
2653
2534
        src_repo = self.make_repository('repo1')
2654
2535
        src_repo = repository.Repository.open(self.get_url('repo1'))
2655
2536
        # At the moment the tarball-based copy_content_into can't write back
2803
2684
        expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
2804
2685
        self.assertEqual(expected_error, translated_error)
2805
2686
 
2806
 
    def test_nobranch_one_arg(self):
2807
 
        bzrdir = self.make_bzrdir('')
2808
 
        translated_error = self.translateTuple(
2809
 
            ('nobranch', 'extra detail'), bzrdir=bzrdir)
2810
 
        expected_error = errors.NotBranchError(
2811
 
            path=bzrdir.root_transport.base,
2812
 
            detail='extra detail')
2813
 
        self.assertEqual(expected_error, translated_error)
2814
 
 
2815
2687
    def test_LockContention(self):
2816
2688
        translated_error = self.translateTuple(('LockContention',))
2817
2689
        expected_error = errors.LockContention('(remote lock)')
2930
2802
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2931
2803
        # been muttered to the log file for developer to look at.
2932
2804
        self.assertContainsRe(
2933
 
            self.get_log(),
 
2805
            self._get_log(keep_log_file=True),
2934
2806
            "Missing key 'branch' in context")
2935
2807
 
2936
2808
    def test_path_missing(self):
2944
2816
        self.assertEqual(server_error, translated_error)
2945
2817
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2946
2818
        # been muttered to the log file for developer to look at.
2947
 
        self.assertContainsRe(self.get_log(), "Missing key 'path' in context")
 
2819
        self.assertContainsRe(
 
2820
            self._get_log(keep_log_file=True), "Missing key 'path' in context")
2948
2821
 
2949
2822
 
2950
2823
class TestStacking(tests.TestCaseWithTransport):
2968
2841
        stacked_branch = self.make_branch('stacked', format='1.9')
2969
2842
        stacked_branch.set_stacked_on_url('../base')
2970
2843
        # start a server looking at this
2971
 
        smart_server = test_server.SmartTCPServer_for_testing()
 
2844
        smart_server = server.SmartTCPServer_for_testing()
2972
2845
        self.start_server(smart_server)
2973
2846
        remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
2974
2847
        # can get its branch and repository
3078
2951
            local_tree.commit('more local changes are better')
3079
2952
            branch = Branch.open(self.get_url('tree3'))
3080
2953
            branch.lock_read()
3081
 
            self.addCleanup(branch.unlock)
3082
2954
            return None, branch
3083
2955
        rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
3084
2956
            branch_factory=make_stacked_stacked)
3130
3002
        super(TestRemoteBranchEffort, self).setUp()
3131
3003
        # Create a smart server that publishes whatever the backing VFS server
3132
3004
        # does.
3133
 
        self.smart_server = test_server.SmartTCPServer_for_testing()
 
3005
        self.smart_server = server.SmartTCPServer_for_testing()
3134
3006
        self.start_server(self.smart_server, self.get_server())
3135
3007
        # Log all HPSS calls into self.hpss_calls.
3136
3008
        _SmartClient.hooks.install_named_hook(