← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_remote.py

  • Committer: John Arbash Meinel
  • Date: 2009-12-18 05:38:40 UTC
  • mto: (4634.108.4 2.0)
  • mto: This revision was merged to the branch mainline in revision 4928.
  • Revision ID: john@arbash-meinel.com-20091218053840-d1636x6jf5i3peym
Of course, it helps if you tell the buffered file that it is writable.

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/',),
769
689
        # fallback all the way to the first version.
770
690
        reference_format = self.get_repo_format()
771
691
        network_name = reference_format.network_name()
772
 
        server_url = 'bzr://example.com/'
773
 
        self.permit_url(server_url)
774
 
        client = FakeClient(server_url)
 
692
        client = FakeClient('bzr://example.com/')
775
693
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
776
694
        client.add_unknown_method_response('BzrDir.find_repositoryV2')
777
695
        client.add_success_response('ok', '', 'no', 'no')
783
701
            reference_format.get_format_string(), 'ok')
784
702
        # PackRepository wants to do a stat
785
703
        client.add_success_response('stat', '0', '65535')
786
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
704
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
787
705
            _client=client)
788
706
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
789
707
            _client=client)
803
721
        # fallback to find_repositoryV2
804
722
        reference_format = self.get_repo_format()
805
723
        network_name = reference_format.network_name()
806
 
        server_url = 'bzr://example.com/'
807
 
        self.permit_url(server_url)
808
 
        client = FakeClient(server_url)
 
724
        client = FakeClient('bzr://example.com/')
809
725
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
810
726
        client.add_success_response('ok', '', 'no', 'no', 'no')
811
727
        # A real repository instance will be created to determine the network
816
732
            reference_format.get_format_string(), 'ok')
817
733
        # PackRepository wants to do a stat
818
734
        client.add_success_response('stat', '0', '65535')
819
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
735
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
820
736
            _client=client)
821
737
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
822
738
            _client=client)
1220
1136
        client = FakeClient(self.get_url())
1221
1137
        branch_network_name = self.get_branch_format().network_name()
1222
1138
        client.add_expected_call(
1223
 
            'BzrDir.open_branchV3', ('stacked/',),
 
1139
            'BzrDir.open_branchV2', ('stacked/',),
1224
1140
            'success', ('branch', branch_network_name))
1225
1141
        client.add_expected_call(
1226
1142
            'BzrDir.find_repositoryV3', ('stacked/',),
1248
1164
            len(branch.repository._real_repository._fallback_repositories))
1249
1165
 
1250
1166
    def test_get_stacked_on_real_branch(self):
1251
 
        base_branch = self.make_branch('base')
1252
 
        stacked_branch = self.make_branch('stacked')
 
1167
        base_branch = self.make_branch('base', format='1.6')
 
1168
        stacked_branch = self.make_branch('stacked', format='1.6')
1253
1169
        stacked_branch.set_stacked_on_url('../base')
1254
1170
        reference_format = self.get_repo_format()
1255
1171
        network_name = reference_format.network_name()
1256
1172
        client = FakeClient(self.get_url())
1257
1173
        branch_network_name = self.get_branch_format().network_name()
1258
1174
        client.add_expected_call(
1259
 
            'BzrDir.open_branchV3', ('stacked/',),
 
1175
            'BzrDir.open_branchV2', ('stacked/',),
1260
1176
            'success', ('branch', branch_network_name))
1261
1177
        client.add_expected_call(
1262
1178
            'BzrDir.find_repositoryV3', ('stacked/',),
1263
 
            'success', ('ok', '', 'yes', 'no', 'yes', network_name))
 
1179
            'success', ('ok', '', 'no', 'no', 'yes', network_name))
1264
1180
        # called twice, once from constructor and then again by us
1265
1181
        client.add_expected_call(
1266
1182
            'Branch.get_stacked_on_url', ('stacked/',),
1811
1727
        return repo, client
1812
1728
 
1813
1729
 
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
1730
class TestRepositoryFormat(TestRemoteRepository):
1829
1731
 
1830
1732
    def test_fast_delta(self):
1837
1739
        false_format._network_name = false_name
1838
1740
        self.assertEqual(False, false_format.fast_deltas)
1839
1741
 
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
1742
 
1848
1743
class TestRepositoryGatherStats(TestRemoteRepository):
1849
1744
 
2034
1929
        self.assertLength(1, self.hpss_calls)
2035
1930
 
2036
1931
    def disableExtraResults(self):
2037
 
        self.overrideAttr(SmartServerRepositoryGetParentMap,
2038
 
                          'no_extra_results', True)
 
1932
        old_flag = SmartServerRepositoryGetParentMap.no_extra_results
 
1933
        SmartServerRepositoryGetParentMap.no_extra_results = True
 
1934
        def reset_values():
 
1935
            SmartServerRepositoryGetParentMap.no_extra_results = old_flag
 
1936
        self.addCleanup(reset_values)
2039
1937
 
2040
1938
    def test_null_cached_missing_and_stop_key(self):
2041
1939
        self.setup_smart_server_with_call_log()
2100
1998
 
2101
1999
    def test_allows_new_revisions(self):
2102
2000
        """get_parent_map's results can be updated by commit."""
2103
 
        smart_server = test_server.SmartTCPServer_for_testing()
2104
 
        self.start_server(smart_server)
 
2001
        smart_server = server.SmartTCPServer_for_testing()
 
2002
        smart_server.setUp()
 
2003
        self.addCleanup(smart_server.tearDown)
2105
2004
        self.make_branch('branch')
2106
2005
        branch = Branch.open(smart_server.get_url() + '/branch')
2107
2006
        tree = branch.create_checkout('tree', lightweight=True)
2216
2115
        """
2217
2116
        # Make a repo with a fallback repo, both using a FakeClient.
2218
2117
        format = remote.response_tuple_to_repo_format(
2219
 
            ('yes', 'no', 'yes', self.get_repo_format().network_name()))
 
2118
            ('yes', 'no', 'yes', 'fake-network-name'))
2220
2119
        repo, client = self.setup_fake_client_and_repository('quack')
2221
2120
        repo._format = format
2222
2121
        fallback_repo, ignored = self.setup_fake_client_and_repository(
2223
2122
            'fallback')
2224
2123
        fallback_repo._client = client
2225
 
        fallback_repo._format = format
2226
2124
        repo.add_fallback_repository(fallback_repo)
2227
2125
        # First the client should ask the primary repo
2228
2126
        client.add_expected_call(
2649
2547
    """RemoteRepository.copy_content_into optimizations"""
2650
2548
 
2651
2549
    def test_copy_content_remote_to_local(self):
2652
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2550
        self.transport_server = server.SmartTCPServer_for_testing
2653
2551
        src_repo = self.make_repository('repo1')
2654
2552
        src_repo = repository.Repository.open(self.get_url('repo1'))
2655
2553
        # At the moment the tarball-based copy_content_into can't write back
2803
2701
        expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
2804
2702
        self.assertEqual(expected_error, translated_error)
2805
2703
 
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
2704
    def test_LockContention(self):
2816
2705
        translated_error = self.translateTuple(('LockContention',))
2817
2706
        expected_error = errors.LockContention('(remote lock)')
2930
2819
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2931
2820
        # been muttered to the log file for developer to look at.
2932
2821
        self.assertContainsRe(
2933
 
            self.get_log(),
 
2822
            self._get_log(keep_log_file=True),
2934
2823
            "Missing key 'branch' in context")
2935
2824
 
2936
2825
    def test_path_missing(self):
2944
2833
        self.assertEqual(server_error, translated_error)
2945
2834
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2946
2835
        # been muttered to the log file for developer to look at.
2947
 
        self.assertContainsRe(self.get_log(), "Missing key 'path' in context")
 
2836
        self.assertContainsRe(
 
2837
            self._get_log(keep_log_file=True), "Missing key 'path' in context")
2948
2838
 
2949
2839
 
2950
2840
class TestStacking(tests.TestCaseWithTransport):
2968
2858
        stacked_branch = self.make_branch('stacked', format='1.9')
2969
2859
        stacked_branch.set_stacked_on_url('../base')
2970
2860
        # start a server looking at this
2971
 
        smart_server = test_server.SmartTCPServer_for_testing()
2972
 
        self.start_server(smart_server)
 
2861
        smart_server = server.SmartTCPServer_for_testing()
 
2862
        smart_server.setUp()
 
2863
        self.addCleanup(smart_server.tearDown)
2973
2864
        remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
2974
2865
        # can get its branch and repository
2975
2866
        remote_branch = remote_bzrdir.open_branch()
3078
2969
            local_tree.commit('more local changes are better')
3079
2970
            branch = Branch.open(self.get_url('tree3'))
3080
2971
            branch.lock_read()
3081
 
            self.addCleanup(branch.unlock)
3082
2972
            return None, branch
3083
2973
        rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
3084
2974
            branch_factory=make_stacked_stacked)
3130
3020
        super(TestRemoteBranchEffort, self).setUp()
3131
3021
        # Create a smart server that publishes whatever the backing VFS server
3132
3022
        # does.
3133
 
        self.smart_server = test_server.SmartTCPServer_for_testing()
3134
 
        self.start_server(self.smart_server, self.get_server())
 
3023
        self.smart_server = server.SmartTCPServer_for_testing()
 
3024
        self.smart_server.setUp(self.get_server())
 
3025
        self.addCleanup(self.smart_server.tearDown)
3135
3026
        # Log all HPSS calls into self.hpss_calls.
3136
3027
        _SmartClient.hooks.install_named_hook(
3137
3028
            'call', self.capture_hpss_call, None)