← 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: Canonical.com Patch Queue Manager
  • Date: 2009-08-13 14:20:03 UTC
  • mfrom: (4599.2.4 windows-installer)
  • Revision ID: pqm@pqm.ubuntu.com-20090813142003-3x748ymw3avzmme7
(jam) Updates to the windows installers.

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
 
    controldir,
34
32
    errors,
35
33
    graph,
36
 
    inventory,
37
 
    inventory_delta,
 
34
    pack,
38
35
    remote,
39
36
    repository,
 
37
    smart,
40
38
    tests,
41
 
    transport,
42
39
    treebuilder,
43
 
    versionedfile,
 
40
    urlutils,
44
41
    )
45
42
from bzrlib.branch import Branch
46
 
from bzrlib.bzrdir import (
47
 
    BzrDir,
48
 
    BzrDirFormat,
49
 
    RemoteBzrProber,
50
 
    )
 
43
from bzrlib.bzrdir import BzrDir, BzrDirFormat
51
44
from bzrlib.remote import (
52
45
    RemoteBranch,
53
46
    RemoteBranchFormat,
54
47
    RemoteBzrDir,
 
48
    RemoteBzrDirFormat,
55
49
    RemoteRepository,
56
50
    RemoteRepositoryFormat,
57
51
    )
58
52
from bzrlib.repofmt import groupcompress_repo, pack_repo
59
53
from bzrlib.revision import NULL_REVISION
60
 
from bzrlib.smart import medium
 
54
from bzrlib.smart import server, medium
61
55
from bzrlib.smart.client import _SmartClient
62
56
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
63
57
from bzrlib.tests import (
64
58
    condition_isinstance,
65
59
    split_suite_by_condition,
66
60
    multiply_tests,
67
 
    test_server,
 
61
    KnownFailure,
68
62
    )
 
63
from bzrlib.transport import get_transport, http
69
64
from bzrlib.transport.memory import MemoryTransport
70
65
from bzrlib.transport.remote import (
71
66
    RemoteTransport,
78
73
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
79
74
    smart_server_version_scenarios = [
80
75
        ('HPSS-v2',
81
 
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
 
76
            {'transport_server': server.SmartTCPServer_for_testing_v2_only}),
82
77
        ('HPSS-v3',
83
 
         {'transport_server': test_server.SmartTCPServer_for_testing})]
 
78
            {'transport_server': server.SmartTCPServer_for_testing})]
84
79
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
85
80
 
86
81
 
91
86
        self.transport = self.get_transport()
92
87
        # make a branch that can be opened over the smart transport
93
88
        self.local_wt = BzrDir.create_standalone_workingtree('.')
94
 
        self.addCleanup(self.transport.disconnect)
 
89
 
 
90
    def tearDown(self):
 
91
        self.transport.disconnect()
 
92
        tests.TestCaseWithTransport.tearDown(self)
95
93
 
96
94
    def test_create_remote_bzrdir(self):
97
95
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
121
119
    def test_find_correct_format(self):
122
120
        """Should open a RemoteBzrDir over a RemoteTransport"""
123
121
        fmt = BzrDirFormat.find_format(self.transport)
124
 
        self.assertTrue(bzrdir.RemoteBzrProber
125
 
                        in controldir.ControlDirFormat._server_probers)
 
122
        self.assertTrue(RemoteBzrDirFormat
 
123
                        in BzrDirFormat._control_server_formats)
126
124
        self.assertIsInstance(fmt, remote.RemoteBzrDirFormat)
127
125
 
128
126
    def test_open_detected_smart_format(self):
134
132
        b = BzrDir.open_from_transport(self.transport).open_branch()
135
133
        self.assertStartsWith(str(b), 'RemoteBranch(')
136
134
 
137
 
    def test_remote_bzrdir_repr(self):
138
 
        b = BzrDir.open_from_transport(self.transport)
139
 
        self.assertStartsWith(str(b), 'RemoteBzrDir(')
140
 
 
141
135
    def test_remote_branch_format_supports_stacking(self):
142
136
        t = self.transport
143
137
        self.make_branch('unstackable', format='pack-0.92')
283
277
        self.expecting_body = True
284
278
        return result[1], FakeProtocol(result[2], self)
285
279
 
286
 
    def call_with_body_bytes(self, method, args, body):
287
 
        self._check_call(method, args)
288
 
        self._calls.append(('call_with_body_bytes', method, args, body))
289
 
        result = self._get_next_response()
290
 
        return result[1], FakeProtocol(result[2], self)
291
 
 
292
280
    def call_with_body_bytes_expecting_body(self, method, args, body):
293
281
        self._check_call(method, args)
294
282
        self._calls.append(('call_with_body_bytes_expecting_body', method,
344
332
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
345
333
        return reference_bzrdir_format.repository_format
346
334
 
 
335
    def disable_verb(self, verb):
 
336
        """Disable a verb for one test."""
 
337
        request_handlers = smart.request.request_handlers
 
338
        orig_method = request_handlers.get(verb)
 
339
        request_handlers.remove(verb)
 
340
        def restoreVerb():
 
341
            request_handlers.register(verb, orig_method)
 
342
        self.addCleanup(restoreVerb)
 
343
 
347
344
    def assertFinished(self, fake_client):
348
345
        """Assert that all of a FakeClient's expected calls have occurred."""
349
346
        fake_client.finished_test()
358
355
        a given client_base and transport_base.
359
356
        """
360
357
        client_medium = medium.SmartClientMedium(client_base)
361
 
        t = transport.get_transport(transport_base)
362
 
        result = client_medium.remote_path_from_transport(t)
 
358
        transport = get_transport(transport_base)
 
359
        result = client_medium.remote_path_from_transport(transport)
363
360
        self.assertEqual(expected, result)
364
361
 
365
362
    def test_remote_path_from_transport(self):
376
373
        a given transport_base and relpath of that transport.  (Note that
377
374
        HttpTransportBase is a subclass of SmartClientMedium)
378
375
        """
379
 
        base_transport = transport.get_transport(transport_base)
 
376
        base_transport = get_transport(transport_base)
380
377
        client_medium = base_transport.get_smart_medium()
381
378
        cloned_transport = base_transport.clone(relpath)
382
379
        result = client_medium.remote_path_from_transport(cloned_transport)
417
414
        # Calling _remember_remote_is_before again with a lower value works.
418
415
        client_medium._remember_remote_is_before((1, 5))
419
416
        self.assertTrue(client_medium._is_remote_before((1, 5)))
420
 
        # If you call _remember_remote_is_before with a higher value it logs a
421
 
        # warning, and continues to remember the lower value.
422
 
        self.assertNotContainsRe(self.get_log(), '_remember_remote_is_before')
423
 
        client_medium._remember_remote_is_before((1, 9))
424
 
        self.assertContainsRe(self.get_log(), '_remember_remote_is_before')
425
 
        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))
426
420
 
427
421
 
428
422
class TestBzrDirCloningMetaDir(TestRemote):
447
441
            'BzrDir.cloning_metadir', ('quack/', 'False'),
448
442
            'error', ('BranchReference',)),
449
443
        client.add_expected_call(
450
 
            'BzrDir.open_branchV3', ('quack/',),
 
444
            'BzrDir.open_branchV2', ('quack/',),
451
445
            'success', ('ref', self.get_url('referenced'))),
452
446
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
453
447
            _client=client)
480
474
        self.assertFinished(client)
481
475
 
482
476
 
483
 
class TestBzrDirOpen(TestRemote):
484
 
 
485
 
    def make_fake_client_and_transport(self, path='quack'):
486
 
        transport = MemoryTransport()
487
 
        transport.mkdir(path)
488
 
        transport = transport.clone(path)
489
 
        client = FakeClient(transport.base)
490
 
        return client, transport
491
 
 
492
 
    def test_absent(self):
493
 
        client, transport = self.make_fake_client_and_transport()
494
 
        client.add_expected_call(
495
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
496
 
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
497
 
                remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
498
 
        self.assertFinished(client)
499
 
 
500
 
    def test_present_without_workingtree(self):
501
 
        client, transport = self.make_fake_client_and_transport()
502
 
        client.add_expected_call(
503
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
504
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
505
 
            _client=client, _force_probe=True)
506
 
        self.assertIsInstance(bd, RemoteBzrDir)
507
 
        self.assertFalse(bd.has_workingtree())
508
 
        self.assertRaises(errors.NoWorkingTree, bd.open_workingtree)
509
 
        self.assertFinished(client)
510
 
 
511
 
    def test_present_with_workingtree(self):
512
 
        client, transport = self.make_fake_client_and_transport()
513
 
        client.add_expected_call(
514
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
515
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
516
 
            _client=client, _force_probe=True)
517
 
        self.assertIsInstance(bd, RemoteBzrDir)
518
 
        self.assertTrue(bd.has_workingtree())
519
 
        self.assertRaises(errors.NotLocalUrl, bd.open_workingtree)
520
 
        self.assertFinished(client)
521
 
 
522
 
    def test_backwards_compat(self):
523
 
        client, transport = self.make_fake_client_and_transport()
524
 
        client.add_expected_call(
525
 
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
526
 
        client.add_expected_call(
527
 
            'BzrDir.open', ('quack/',), 'success', ('yes',))
528
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
529
 
            _client=client, _force_probe=True)
530
 
        self.assertIsInstance(bd, RemoteBzrDir)
531
 
        self.assertFinished(client)
532
 
 
533
 
    def test_backwards_compat_hpss_v2(self):
534
 
        client, transport = self.make_fake_client_and_transport()
535
 
        # Monkey-patch fake client to simulate real-world behaviour with v2
536
 
        # server: upon first RPC call detect the protocol version, and because
537
 
        # the version is 2 also do _remember_remote_is_before((1, 6)) before
538
 
        # continuing with the RPC.
539
 
        orig_check_call = client._check_call
540
 
        def check_call(method, args):
541
 
            client._medium._protocol_version = 2
542
 
            client._medium._remember_remote_is_before((1, 6))
543
 
            client._check_call = orig_check_call
544
 
            client._check_call(method, args)
545
 
        client._check_call = check_call
546
 
        client.add_expected_call(
547
 
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
548
 
        client.add_expected_call(
549
 
            'BzrDir.open', ('quack/',), 'success', ('yes',))
550
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
551
 
            _client=client, _force_probe=True)
552
 
        self.assertIsInstance(bd, RemoteBzrDir)
553
 
        self.assertFinished(client)
554
 
 
555
 
 
556
477
class TestBzrDirOpenBranch(TestRemote):
557
478
 
558
479
    def test_backwards_compat(self):
560
481
        self.make_branch('.')
561
482
        a_dir = BzrDir.open(self.get_url('.'))
562
483
        self.reset_smart_call_log()
563
 
        verb = 'BzrDir.open_branchV3'
 
484
        verb = 'BzrDir.open_branchV2'
564
485
        self.disable_verb(verb)
565
486
        format = a_dir.open_branch()
566
487
        call_count = len([call for call in self.hpss_calls if
576
497
        transport = transport.clone('quack')
577
498
        client = FakeClient(transport.base)
578
499
        client.add_expected_call(
579
 
            'BzrDir.open_branchV3', ('quack/',),
 
500
            'BzrDir.open_branchV2', ('quack/',),
580
501
            'success', ('branch', branch_network_name))
581
502
        client.add_expected_call(
582
503
            'BzrDir.find_repositoryV3', ('quack/',),
601
522
            _client=client)
602
523
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
603
524
        self.assertEqual(
604
 
            [('call', 'BzrDir.open_branchV3', ('quack/',))],
 
525
            [('call', 'BzrDir.open_branchV2', ('quack/',))],
605
526
            client._calls)
606
527
 
607
528
    def test__get_tree_branch(self):
608
529
        # _get_tree_branch is a form of open_branch, but it should only ask for
609
530
        # branch opening, not any other network requests.
610
531
        calls = []
611
 
        def open_branch(name=None):
 
532
        def open_branch():
612
533
            calls.append("Called")
613
534
            return "a-branch"
614
535
        transport = MemoryTransport()
631
552
        network_name = reference_format.network_name()
632
553
        branch_network_name = self.get_branch_format().network_name()
633
554
        client.add_expected_call(
634
 
            'BzrDir.open_branchV3', ('~hello/',),
 
555
            'BzrDir.open_branchV2', ('~hello/',),
635
556
            'success', ('branch', branch_network_name))
636
557
        client.add_expected_call(
637
558
            'BzrDir.find_repositoryV3', ('~hello/',),
685
606
        old.
686
607
        """
687
608
        self.assertRaises(errors.NotBranchError,
688
 
            RemoteBzrProber.probe_transport, OldServerTransport())
 
609
            RemoteBzrDirFormat.probe_transport, OldServerTransport())
689
610
 
690
611
 
691
612
class TestBzrDirCreateBranch(TestRemote):
746
667
        network_name = reference_format.network_name()
747
668
        client.add_expected_call(
748
669
            'BzrDir.create_repository', ('quack/',
749
 
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
750
 
                'False'),
751
 
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
 
670
                'Bazaar pack repository format 1 (needs bzr 0.92)\n', 'False'),
 
671
            'success', ('ok', 'no', 'no', 'no', network_name))
752
672
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
753
673
            _client=client)
754
674
        repo = a_bzrdir.create_repository()
756
676
        self.assertIsInstance(repo, remote.RemoteRepository)
757
677
        # its format should have the settings from the response
758
678
        format = repo._format
759
 
        self.assertTrue(format.rich_root_data)
760
 
        self.assertTrue(format.supports_tree_reference)
761
 
        self.assertTrue(format.supports_external_lookups)
 
679
        self.assertFalse(format.rich_root_data)
 
680
        self.assertFalse(format.supports_tree_reference)
 
681
        self.assertFalse(format.supports_external_lookups)
762
682
        self.assertEqual(network_name, format.network_name())
763
683
 
764
684
 
768
688
        # fallback all the way to the first version.
769
689
        reference_format = self.get_repo_format()
770
690
        network_name = reference_format.network_name()
771
 
        server_url = 'bzr://example.com/'
772
 
        self.permit_url(server_url)
773
 
        client = FakeClient(server_url)
 
691
        client = FakeClient('bzr://example.com/')
774
692
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
775
693
        client.add_unknown_method_response('BzrDir.find_repositoryV2')
776
694
        client.add_success_response('ok', '', 'no', 'no')
782
700
            reference_format.get_format_string(), 'ok')
783
701
        # PackRepository wants to do a stat
784
702
        client.add_success_response('stat', '0', '65535')
785
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
703
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
786
704
            _client=client)
787
705
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
788
706
            _client=client)
802
720
        # fallback to find_repositoryV2
803
721
        reference_format = self.get_repo_format()
804
722
        network_name = reference_format.network_name()
805
 
        server_url = 'bzr://example.com/'
806
 
        self.permit_url(server_url)
807
 
        client = FakeClient(server_url)
 
723
        client = FakeClient('bzr://example.com/')
808
724
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
809
725
        client.add_success_response('ok', '', 'no', 'no', 'no')
810
726
        # A real repository instance will be created to determine the network
815
731
            reference_format.get_format_string(), 'ok')
816
732
        # PackRepository wants to do a stat
817
733
        client.add_success_response('stat', '0', '65535')
818
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
734
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
819
735
            _client=client)
820
736
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
821
737
            _client=client)
940
856
 
941
857
class RemoteBranchTestCase(RemoteBzrDirTestCase):
942
858
 
943
 
    def lock_remote_branch(self, branch):
944
 
        """Trick a RemoteBranch into thinking it is locked."""
945
 
        branch._lock_mode = 'w'
946
 
        branch._lock_count = 2
947
 
        branch._lock_token = 'branch token'
948
 
        branch._repo_lock_token = 'repo token'
949
 
        branch.repository._lock_mode = 'w'
950
 
        branch.repository._lock_count = 2
951
 
        branch.repository._lock_token = 'repo token'
952
 
 
953
859
    def make_remote_branch(self, transport, client):
954
860
        """Make a RemoteBranch using 'client' as its _SmartClient.
955
861
 
1094
1000
        self.assertEqual({}, result)
1095
1001
 
1096
1002
 
1097
 
class TestBranchSetTagsBytes(RemoteBranchTestCase):
1098
 
 
1099
 
    def test_trivial(self):
1100
 
        transport = MemoryTransport()
1101
 
        client = FakeClient(transport.base)
1102
 
        client.add_expected_call(
1103
 
            'Branch.get_stacked_on_url', ('quack/',),
1104
 
            'error', ('NotStacked',))
1105
 
        client.add_expected_call(
1106
 
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1107
 
            'success', ('',))
1108
 
        transport.mkdir('quack')
1109
 
        transport = transport.clone('quack')
1110
 
        branch = self.make_remote_branch(transport, client)
1111
 
        self.lock_remote_branch(branch)
1112
 
        branch._set_tags_bytes('tags bytes')
1113
 
        self.assertFinished(client)
1114
 
        self.assertEqual('tags bytes', client._calls[-1][-1])
1115
 
 
1116
 
    def test_backwards_compatible(self):
1117
 
        transport = MemoryTransport()
1118
 
        client = FakeClient(transport.base)
1119
 
        client.add_expected_call(
1120
 
            'Branch.get_stacked_on_url', ('quack/',),
1121
 
            'error', ('NotStacked',))
1122
 
        client.add_expected_call(
1123
 
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1124
 
            'unknown', ('Branch.set_tags_bytes',))
1125
 
        transport.mkdir('quack')
1126
 
        transport = transport.clone('quack')
1127
 
        branch = self.make_remote_branch(transport, client)
1128
 
        self.lock_remote_branch(branch)
1129
 
        class StubRealBranch(object):
1130
 
            def __init__(self):
1131
 
                self.calls = []
1132
 
            def _set_tags_bytes(self, bytes):
1133
 
                self.calls.append(('set_tags_bytes', bytes))
1134
 
        real_branch = StubRealBranch()
1135
 
        branch._real_branch = real_branch
1136
 
        branch._set_tags_bytes('tags bytes')
1137
 
        # Call a second time, to exercise the 'remote version already inferred'
1138
 
        # code path.
1139
 
        branch._set_tags_bytes('tags bytes')
1140
 
        self.assertFinished(client)
1141
 
        self.assertEqual(
1142
 
            [('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1143
 
 
1144
 
 
1145
1003
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1146
1004
 
1147
1005
    def test_empty_branch(self):
1219
1077
        client = FakeClient(self.get_url())
1220
1078
        branch_network_name = self.get_branch_format().network_name()
1221
1079
        client.add_expected_call(
1222
 
            'BzrDir.open_branchV3', ('stacked/',),
 
1080
            'BzrDir.open_branchV2', ('stacked/',),
1223
1081
            'success', ('branch', branch_network_name))
1224
1082
        client.add_expected_call(
1225
1083
            'BzrDir.find_repositoryV3', ('stacked/',),
1247
1105
            len(branch.repository._real_repository._fallback_repositories))
1248
1106
 
1249
1107
    def test_get_stacked_on_real_branch(self):
1250
 
        base_branch = self.make_branch('base')
1251
 
        stacked_branch = self.make_branch('stacked')
 
1108
        base_branch = self.make_branch('base', format='1.6')
 
1109
        stacked_branch = self.make_branch('stacked', format='1.6')
1252
1110
        stacked_branch.set_stacked_on_url('../base')
1253
1111
        reference_format = self.get_repo_format()
1254
1112
        network_name = reference_format.network_name()
1255
1113
        client = FakeClient(self.get_url())
1256
1114
        branch_network_name = self.get_branch_format().network_name()
1257
1115
        client.add_expected_call(
1258
 
            'BzrDir.open_branchV3', ('stacked/',),
 
1116
            'BzrDir.open_branchV2', ('stacked/',),
1259
1117
            'success', ('branch', branch_network_name))
1260
1118
        client.add_expected_call(
1261
1119
            'BzrDir.find_repositoryV3', ('stacked/',),
1262
 
            'success', ('ok', '', 'yes', 'no', 'yes', network_name))
 
1120
            'success', ('ok', '', 'no', 'no', 'yes', network_name))
1263
1121
        # called twice, once from constructor and then again by us
1264
1122
        client.add_expected_call(
1265
1123
            'Branch.get_stacked_on_url', ('stacked/',),
1489
1347
            errors.NoSuchRevision, branch.set_last_revision_info, 123, 'revid')
1490
1348
        branch.unlock()
1491
1349
 
 
1350
    def lock_remote_branch(self, branch):
 
1351
        """Trick a RemoteBranch into thinking it is locked."""
 
1352
        branch._lock_mode = 'w'
 
1353
        branch._lock_count = 2
 
1354
        branch._lock_token = 'branch token'
 
1355
        branch._repo_lock_token = 'repo token'
 
1356
        branch.repository._lock_mode = 'w'
 
1357
        branch.repository._lock_count = 2
 
1358
        branch.repository._lock_token = 'repo token'
 
1359
 
1492
1360
    def test_backwards_compatibility(self):
1493
1361
        """If the server does not support the Branch.set_last_revision_info
1494
1362
        verb (which is new in 1.4), then the client falls back to VFS methods.
1617
1485
    def test_get_multi_line_branch_conf(self):
1618
1486
        # Make sure that multiple-line branch.conf files are supported
1619
1487
        #
1620
 
        # https://bugs.launchpad.net/bzr/+bug/354075
 
1488
        # https://bugs.edge.launchpad.net/bzr/+bug/354075
1621
1489
        client = FakeClient()
1622
1490
        client.add_expected_call(
1623
1491
            'Branch.get_stacked_on_url', ('memory:///',),
1651
1519
        branch.unlock()
1652
1520
        self.assertFinished(client)
1653
1521
 
1654
 
    def test_set_option_with_dict(self):
1655
 
        client = FakeClient()
1656
 
        client.add_expected_call(
1657
 
            'Branch.get_stacked_on_url', ('memory:///',),
1658
 
            'error', ('NotStacked',),)
1659
 
        client.add_expected_call(
1660
 
            'Branch.lock_write', ('memory:///', '', ''),
1661
 
            'success', ('ok', 'branch token', 'repo token'))
1662
 
        encoded_dict_value = 'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde'
1663
 
        client.add_expected_call(
1664
 
            'Branch.set_config_option_dict', ('memory:///', 'branch token',
1665
 
            'repo token', encoded_dict_value, 'foo', ''),
1666
 
            'success', ())
1667
 
        client.add_expected_call(
1668
 
            'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
1669
 
            'success', ('ok',))
1670
 
        transport = MemoryTransport()
1671
 
        branch = self.make_remote_branch(transport, client)
1672
 
        branch.lock_write()
1673
 
        config = branch._get_config()
1674
 
        config.set_option(
1675
 
            {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'},
1676
 
            'foo')
1677
 
        branch.unlock()
1678
 
        self.assertFinished(client)
1679
 
 
1680
1522
    def test_backwards_compat_set_option(self):
1681
1523
        self.setup_smart_server_with_call_log()
1682
1524
        branch = self.make_branch('.')
1689
1531
        self.assertLength(10, self.hpss_calls)
1690
1532
        self.assertEqual('value', branch._get_config().get_option('name'))
1691
1533
 
1692
 
    def test_backwards_compat_set_option_with_dict(self):
1693
 
        self.setup_smart_server_with_call_log()
1694
 
        branch = self.make_branch('.')
1695
 
        verb = 'Branch.set_config_option_dict'
1696
 
        self.disable_verb(verb)
1697
 
        branch.lock_write()
1698
 
        self.addCleanup(branch.unlock)
1699
 
        self.reset_smart_call_log()
1700
 
        config = branch._get_config()
1701
 
        value_dict = {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
1702
 
        config.set_option(value_dict, 'name')
1703
 
        self.assertLength(10, self.hpss_calls)
1704
 
        self.assertEqual(value_dict, branch._get_config().get_option('name'))
1705
 
 
1706
1534
 
1707
1535
class TestBranchLockWrite(RemoteBranchTestCase):
1708
1536
 
1850
1678
        return repo, client
1851
1679
 
1852
1680
 
1853
 
def remoted_description(format):
1854
 
    return 'Remote: ' + format.get_format_description()
1855
 
 
1856
 
 
1857
 
class TestBranchFormat(tests.TestCase):
1858
 
 
1859
 
    def test_get_format_description(self):
1860
 
        remote_format = RemoteBranchFormat()
1861
 
        real_format = branch.BranchFormat.get_default_format()
1862
 
        remote_format._network_name = real_format.network_name()
1863
 
        self.assertEqual(remoted_description(real_format),
1864
 
            remote_format.get_format_description())
1865
 
 
1866
 
 
1867
1681
class TestRepositoryFormat(TestRemoteRepository):
1868
1682
 
1869
1683
    def test_fast_delta(self):
1876
1690
        false_format._network_name = false_name
1877
1691
        self.assertEqual(False, false_format.fast_deltas)
1878
1692
 
1879
 
    def test_get_format_description(self):
1880
 
        remote_repo_format = RemoteRepositoryFormat()
1881
 
        real_format = repository.RepositoryFormat.get_default_format()
1882
 
        remote_repo_format._network_name = real_format.network_name()
1883
 
        self.assertEqual(remoted_description(real_format),
1884
 
            remote_repo_format.get_format_description())
1885
 
 
1886
1693
 
1887
1694
class TestRepositoryGatherStats(TestRemoteRepository):
1888
1695
 
2073
1880
        self.assertLength(1, self.hpss_calls)
2074
1881
 
2075
1882
    def disableExtraResults(self):
2076
 
        self.overrideAttr(SmartServerRepositoryGetParentMap,
2077
 
                          'no_extra_results', True)
 
1883
        old_flag = SmartServerRepositoryGetParentMap.no_extra_results
 
1884
        SmartServerRepositoryGetParentMap.no_extra_results = True
 
1885
        def reset_values():
 
1886
            SmartServerRepositoryGetParentMap.no_extra_results = old_flag
 
1887
        self.addCleanup(reset_values)
2078
1888
 
2079
1889
    def test_null_cached_missing_and_stop_key(self):
2080
1890
        self.setup_smart_server_with_call_log()
2139
1949
 
2140
1950
    def test_allows_new_revisions(self):
2141
1951
        """get_parent_map's results can be updated by commit."""
2142
 
        smart_server = test_server.SmartTCPServer_for_testing()
2143
 
        self.start_server(smart_server)
 
1952
        smart_server = server.SmartTCPServer_for_testing()
 
1953
        smart_server.setUp()
 
1954
        self.addCleanup(smart_server.tearDown)
2144
1955
        self.make_branch('branch')
2145
1956
        branch = Branch.open(smart_server.get_url() + '/branch')
2146
1957
        tree = branch.create_checkout('tree', lightweight=True)
2255
2066
        """
2256
2067
        # Make a repo with a fallback repo, both using a FakeClient.
2257
2068
        format = remote.response_tuple_to_repo_format(
2258
 
            ('yes', 'no', 'yes', self.get_repo_format().network_name()))
 
2069
            ('yes', 'no', 'yes', 'fake-network-name'))
2259
2070
        repo, client = self.setup_fake_client_and_repository('quack')
2260
2071
        repo._format = format
2261
2072
        fallback_repo, ignored = self.setup_fake_client_and_repository(
2262
2073
            'fallback')
2263
2074
        fallback_repo._client = client
2264
 
        fallback_repo._format = format
2265
2075
        repo.add_fallback_repository(fallback_repo)
2266
2076
        # First the client should ask the primary repo
2267
2077
        client.add_expected_call(
2288
2098
            repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
2289
2099
        self.assertFinished(client)
2290
2100
 
2291
 
    def test_branch_fallback_locking(self):
2292
 
        """RemoteBranch.get_rev_id takes a read lock, and tries to call the
2293
 
        get_rev_id_for_revno verb.  If the verb is unknown the VFS fallback
2294
 
        will be invoked, which will fail if the repo is unlocked.
2295
 
        """
2296
 
        self.setup_smart_server_with_call_log()
2297
 
        tree = self.make_branch_and_memory_tree('.')
2298
 
        tree.lock_write()
2299
 
        tree.add('')
2300
 
        rev1 = tree.commit('First')
2301
 
        rev2 = tree.commit('Second')
2302
 
        tree.unlock()
2303
 
        branch = tree.branch
2304
 
        self.assertFalse(branch.is_locked())
2305
 
        self.reset_smart_call_log()
2306
 
        verb = 'Repository.get_rev_id_for_revno'
2307
 
        self.disable_verb(verb)
2308
 
        self.assertEqual(rev1, branch.get_rev_id(1))
2309
 
        self.assertLength(1, [call for call in self.hpss_calls if
2310
 
                              call.call.method == verb])
2311
 
 
2312
2101
 
2313
2102
class TestRepositoryIsShared(TestRemoteRepository):
2314
2103
 
2341
2130
        transport_path = 'quack'
2342
2131
        repo, client = self.setup_fake_client_and_repository(transport_path)
2343
2132
        client.add_success_response('ok', 'a token')
2344
 
        token = repo.lock_write().repository_token
 
2133
        result = repo.lock_write()
2345
2134
        self.assertEqual(
2346
2135
            [('call', 'Repository.lock_write', ('quack/', ''))],
2347
2136
            client._calls)
2348
 
        self.assertEqual('a token', token)
 
2137
        self.assertEqual('a token', result)
2349
2138
 
2350
2139
    def test_lock_write_already_locked(self):
2351
2140
        transport_path = 'quack'
2430
2219
        self.assertEqual([], client._calls)
2431
2220
 
2432
2221
 
2433
 
class TestRepositoryInsertStreamBase(TestRemoteRepository):
2434
 
    """Base class for Repository.insert_stream and .insert_stream_1.19
2435
 
    tests.
2436
 
    """
2437
 
    
2438
 
    def checkInsertEmptyStream(self, repo, client):
2439
 
        """Insert an empty stream, checking the result.
2440
 
 
2441
 
        This checks that there are no resume_tokens or missing_keys, and that
2442
 
        the client is finished.
2443
 
        """
2444
 
        sink = repo._get_sink()
2445
 
        fmt = repository.RepositoryFormat.get_default_format()
2446
 
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2447
 
        self.assertEqual([], resume_tokens)
2448
 
        self.assertEqual(set(), missing_keys)
2449
 
        self.assertFinished(client)
2450
 
 
2451
 
 
2452
 
class TestRepositoryInsertStream(TestRepositoryInsertStreamBase):
2453
 
    """Tests for using Repository.insert_stream verb when the _1.19 variant is
2454
 
    not available.
2455
 
 
2456
 
    This test case is very similar to TestRepositoryInsertStream_1_19.
2457
 
    """
2458
 
 
2459
 
    def setUp(self):
2460
 
        TestRemoteRepository.setUp(self)
2461
 
        self.disable_verb('Repository.insert_stream_1.19')
2462
 
 
2463
 
    def test_unlocked_repo(self):
2464
 
        transport_path = 'quack'
2465
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2466
 
        client.add_expected_call(
2467
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2468
 
            'unknown', ('Repository.insert_stream_1.19',))
2469
 
        client.add_expected_call(
2470
 
            'Repository.insert_stream', ('quack/', ''),
2471
 
            'success', ('ok',))
2472
 
        client.add_expected_call(
2473
 
            'Repository.insert_stream', ('quack/', ''),
2474
 
            'success', ('ok',))
2475
 
        self.checkInsertEmptyStream(repo, client)
2476
 
 
2477
 
    def test_locked_repo_with_no_lock_token(self):
2478
 
        transport_path = 'quack'
2479
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2480
 
        client.add_expected_call(
2481
 
            'Repository.lock_write', ('quack/', ''),
2482
 
            'success', ('ok', ''))
2483
 
        client.add_expected_call(
2484
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2485
 
            'unknown', ('Repository.insert_stream_1.19',))
2486
 
        client.add_expected_call(
2487
 
            'Repository.insert_stream', ('quack/', ''),
2488
 
            'success', ('ok',))
2489
 
        client.add_expected_call(
2490
 
            'Repository.insert_stream', ('quack/', ''),
2491
 
            'success', ('ok',))
2492
 
        repo.lock_write()
2493
 
        self.checkInsertEmptyStream(repo, client)
2494
 
 
2495
 
    def test_locked_repo_with_lock_token(self):
2496
 
        transport_path = 'quack'
2497
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2498
 
        client.add_expected_call(
2499
 
            'Repository.lock_write', ('quack/', ''),
2500
 
            'success', ('ok', 'a token'))
2501
 
        client.add_expected_call(
2502
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2503
 
            'unknown', ('Repository.insert_stream_1.19',))
2504
 
        client.add_expected_call(
2505
 
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2506
 
            'success', ('ok',))
2507
 
        client.add_expected_call(
2508
 
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2509
 
            'success', ('ok',))
2510
 
        repo.lock_write()
2511
 
        self.checkInsertEmptyStream(repo, client)
2512
 
 
2513
 
    def test_stream_with_inventory_deltas(self):
2514
 
        """'inventory-deltas' substreams cannot be sent to the
2515
 
        Repository.insert_stream verb, because not all servers that implement
2516
 
        that verb will accept them.  So when one is encountered the RemoteSink
2517
 
        immediately stops using that verb and falls back to VFS insert_stream.
2518
 
        """
2519
 
        transport_path = 'quack'
2520
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2521
 
        client.add_expected_call(
2522
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2523
 
            'unknown', ('Repository.insert_stream_1.19',))
2524
 
        client.add_expected_call(
2525
 
            'Repository.insert_stream', ('quack/', ''),
2526
 
            'success', ('ok',))
2527
 
        client.add_expected_call(
2528
 
            'Repository.insert_stream', ('quack/', ''),
2529
 
            'success', ('ok',))
2530
 
        # Create a fake real repository for insert_stream to fall back on, so
2531
 
        # that we can directly see the records the RemoteSink passes to the
2532
 
        # real sink.
2533
 
        class FakeRealSink:
2534
 
            def __init__(self):
2535
 
                self.records = []
2536
 
            def insert_stream(self, stream, src_format, resume_tokens):
2537
 
                for substream_kind, substream in stream:
2538
 
                    self.records.append(
2539
 
                        (substream_kind, [record.key for record in substream]))
2540
 
                return ['fake tokens'], ['fake missing keys']
2541
 
        fake_real_sink = FakeRealSink()
2542
 
        class FakeRealRepository:
2543
 
            def _get_sink(self):
2544
 
                return fake_real_sink
2545
 
            def is_in_write_group(self):
2546
 
                return False
2547
 
            def refresh_data(self):
2548
 
                return True
2549
 
        repo._real_repository = FakeRealRepository()
2550
 
        sink = repo._get_sink()
2551
 
        fmt = repository.RepositoryFormat.get_default_format()
2552
 
        stream = self.make_stream_with_inv_deltas(fmt)
2553
 
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2554
 
        # Every record from the first inventory delta should have been sent to
2555
 
        # the VFS sink.
2556
 
        expected_records = [
2557
 
            ('inventory-deltas', [('rev2',), ('rev3',)]),
2558
 
            ('texts', [('some-rev', 'some-file')])]
2559
 
        self.assertEqual(expected_records, fake_real_sink.records)
2560
 
        # The return values from the real sink's insert_stream are propagated
2561
 
        # back to the original caller.
2562
 
        self.assertEqual(['fake tokens'], resume_tokens)
2563
 
        self.assertEqual(['fake missing keys'], missing_keys)
2564
 
        self.assertFinished(client)
2565
 
 
2566
 
    def make_stream_with_inv_deltas(self, fmt):
2567
 
        """Make a simple stream with an inventory delta followed by more
2568
 
        records and more substreams to test that all records and substreams
2569
 
        from that point on are used.
2570
 
 
2571
 
        This sends, in order:
2572
 
           * inventories substream: rev1, rev2, rev3.  rev2 and rev3 are
2573
 
             inventory-deltas.
2574
 
           * texts substream: (some-rev, some-file)
2575
 
        """
2576
 
        # Define a stream using generators so that it isn't rewindable.
2577
 
        inv = inventory.Inventory(revision_id='rev1')
2578
 
        inv.root.revision = 'rev1'
2579
 
        def stream_with_inv_delta():
2580
 
            yield ('inventories', inventories_substream())
2581
 
            yield ('inventory-deltas', inventory_delta_substream())
2582
 
            yield ('texts', [
2583
 
                versionedfile.FulltextContentFactory(
2584
 
                    ('some-rev', 'some-file'), (), None, 'content')])
2585
 
        def inventories_substream():
2586
 
            # An empty inventory fulltext.  This will be streamed normally.
2587
 
            text = fmt._serializer.write_inventory_to_string(inv)
2588
 
            yield versionedfile.FulltextContentFactory(
2589
 
                ('rev1',), (), None, text)
2590
 
        def inventory_delta_substream():
2591
 
            # An inventory delta.  This can't be streamed via this verb, so it
2592
 
            # will trigger a fallback to VFS insert_stream.
2593
 
            entry = inv.make_entry(
2594
 
                'directory', 'newdir', inv.root.file_id, 'newdir-id')
2595
 
            entry.revision = 'ghost'
2596
 
            delta = [(None, 'newdir', 'newdir-id', entry)]
2597
 
            serializer = inventory_delta.InventoryDeltaSerializer(
2598
 
                versioned_root=True, tree_references=False)
2599
 
            lines = serializer.delta_to_lines('rev1', 'rev2', delta)
2600
 
            yield versionedfile.ChunkedContentFactory(
2601
 
                ('rev2',), (('rev1',)), None, lines)
2602
 
            # Another delta.
2603
 
            lines = serializer.delta_to_lines('rev1', 'rev3', delta)
2604
 
            yield versionedfile.ChunkedContentFactory(
2605
 
                ('rev3',), (('rev1',)), None, lines)
2606
 
        return stream_with_inv_delta()
2607
 
 
2608
 
 
2609
 
class TestRepositoryInsertStream_1_19(TestRepositoryInsertStreamBase):
2610
 
 
2611
 
    def test_unlocked_repo(self):
2612
 
        transport_path = 'quack'
2613
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2614
 
        client.add_expected_call(
2615
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2616
 
            'success', ('ok',))
2617
 
        client.add_expected_call(
2618
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2619
 
            'success', ('ok',))
2620
 
        self.checkInsertEmptyStream(repo, client)
2621
 
 
2622
 
    def test_locked_repo_with_no_lock_token(self):
2623
 
        transport_path = 'quack'
2624
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2625
 
        client.add_expected_call(
2626
 
            'Repository.lock_write', ('quack/', ''),
2627
 
            'success', ('ok', ''))
2628
 
        client.add_expected_call(
2629
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2630
 
            'success', ('ok',))
2631
 
        client.add_expected_call(
2632
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2633
 
            'success', ('ok',))
2634
 
        repo.lock_write()
2635
 
        self.checkInsertEmptyStream(repo, client)
2636
 
 
2637
 
    def test_locked_repo_with_lock_token(self):
2638
 
        transport_path = 'quack'
2639
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2640
 
        client.add_expected_call(
2641
 
            'Repository.lock_write', ('quack/', ''),
2642
 
            'success', ('ok', 'a token'))
2643
 
        client.add_expected_call(
2644
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2645
 
            'success', ('ok',))
2646
 
        client.add_expected_call(
2647
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2648
 
            'success', ('ok',))
2649
 
        repo.lock_write()
2650
 
        self.checkInsertEmptyStream(repo, client)
 
2222
class TestRepositoryInsertStream(TestRemoteRepository):
 
2223
 
 
2224
    def test_unlocked_repo(self):
 
2225
        transport_path = 'quack'
 
2226
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2227
        client.add_expected_call(
 
2228
            'Repository.insert_stream', ('quack/', ''),
 
2229
            'success', ('ok',))
 
2230
        client.add_expected_call(
 
2231
            'Repository.insert_stream', ('quack/', ''),
 
2232
            'success', ('ok',))
 
2233
        sink = repo._get_sink()
 
2234
        fmt = repository.RepositoryFormat.get_default_format()
 
2235
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2236
        self.assertEqual([], resume_tokens)
 
2237
        self.assertEqual(set(), missing_keys)
 
2238
        self.assertFinished(client)
 
2239
 
 
2240
    def test_locked_repo_with_no_lock_token(self):
 
2241
        transport_path = 'quack'
 
2242
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2243
        client.add_expected_call(
 
2244
            'Repository.lock_write', ('quack/', ''),
 
2245
            'success', ('ok', ''))
 
2246
        client.add_expected_call(
 
2247
            'Repository.insert_stream', ('quack/', ''),
 
2248
            'success', ('ok',))
 
2249
        client.add_expected_call(
 
2250
            'Repository.insert_stream', ('quack/', ''),
 
2251
            'success', ('ok',))
 
2252
        repo.lock_write()
 
2253
        sink = repo._get_sink()
 
2254
        fmt = repository.RepositoryFormat.get_default_format()
 
2255
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2256
        self.assertEqual([], resume_tokens)
 
2257
        self.assertEqual(set(), missing_keys)
 
2258
        self.assertFinished(client)
 
2259
 
 
2260
    def test_locked_repo_with_lock_token(self):
 
2261
        transport_path = 'quack'
 
2262
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2263
        client.add_expected_call(
 
2264
            'Repository.lock_write', ('quack/', ''),
 
2265
            'success', ('ok', 'a token'))
 
2266
        client.add_expected_call(
 
2267
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
 
2268
            'success', ('ok',))
 
2269
        client.add_expected_call(
 
2270
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
 
2271
            'success', ('ok',))
 
2272
        repo.lock_write()
 
2273
        sink = repo._get_sink()
 
2274
        fmt = repository.RepositoryFormat.get_default_format()
 
2275
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2276
        self.assertEqual([], resume_tokens)
 
2277
        self.assertEqual(set(), missing_keys)
 
2278
        self.assertFinished(client)
2651
2279
 
2652
2280
 
2653
2281
class TestRepositoryTarball(TestRemoteRepository):
2689
2317
    """RemoteRepository.copy_content_into optimizations"""
2690
2318
 
2691
2319
    def test_copy_content_remote_to_local(self):
2692
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2320
        self.transport_server = server.SmartTCPServer_for_testing
2693
2321
        src_repo = self.make_repository('repo1')
2694
2322
        src_repo = repository.Repository.open(self.get_url('repo1'))
2695
2323
        # At the moment the tarball-based copy_content_into can't write back
2843
2471
        expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
2844
2472
        self.assertEqual(expected_error, translated_error)
2845
2473
 
2846
 
    def test_nobranch_one_arg(self):
2847
 
        bzrdir = self.make_bzrdir('')
2848
 
        translated_error = self.translateTuple(
2849
 
            ('nobranch', 'extra detail'), bzrdir=bzrdir)
2850
 
        expected_error = errors.NotBranchError(
2851
 
            path=bzrdir.root_transport.base,
2852
 
            detail='extra detail')
2853
 
        self.assertEqual(expected_error, translated_error)
2854
 
 
2855
2474
    def test_LockContention(self):
2856
2475
        translated_error = self.translateTuple(('LockContention',))
2857
2476
        expected_error = errors.LockContention('(remote lock)')
2897
2516
        expected_error = errors.ReadError(path)
2898
2517
        self.assertEqual(expected_error, translated_error)
2899
2518
 
2900
 
    def test_IncompatibleRepositories(self):
2901
 
        translated_error = self.translateTuple(('IncompatibleRepositories',
2902
 
            "repo1", "repo2", "details here"))
2903
 
        expected_error = errors.IncompatibleRepositories("repo1", "repo2",
2904
 
            "details here")
2905
 
        self.assertEqual(expected_error, translated_error)
2906
 
 
2907
2519
    def test_PermissionDenied_no_args(self):
2908
2520
        path = 'a path'
2909
2521
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
2970
2582
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2971
2583
        # been muttered to the log file for developer to look at.
2972
2584
        self.assertContainsRe(
2973
 
            self.get_log(),
 
2585
            self._get_log(keep_log_file=True),
2974
2586
            "Missing key 'branch' in context")
2975
2587
 
2976
2588
    def test_path_missing(self):
2984
2596
        self.assertEqual(server_error, translated_error)
2985
2597
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2986
2598
        # been muttered to the log file for developer to look at.
2987
 
        self.assertContainsRe(self.get_log(), "Missing key 'path' in context")
 
2599
        self.assertContainsRe(
 
2600
            self._get_log(keep_log_file=True), "Missing key 'path' in context")
2988
2601
 
2989
2602
 
2990
2603
class TestStacking(tests.TestCaseWithTransport):
3008
2621
        stacked_branch = self.make_branch('stacked', format='1.9')
3009
2622
        stacked_branch.set_stacked_on_url('../base')
3010
2623
        # start a server looking at this
3011
 
        smart_server = test_server.SmartTCPServer_for_testing()
3012
 
        self.start_server(smart_server)
 
2624
        smart_server = server.SmartTCPServer_for_testing()
 
2625
        smart_server.setUp()
 
2626
        self.addCleanup(smart_server.tearDown)
3013
2627
        remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
3014
2628
        # can get its branch and repository
3015
2629
        remote_branch = remote_bzrdir.open_branch()
3118
2732
            local_tree.commit('more local changes are better')
3119
2733
            branch = Branch.open(self.get_url('tree3'))
3120
2734
            branch.lock_read()
3121
 
            self.addCleanup(branch.unlock)
3122
2735
            return None, branch
3123
2736
        rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
3124
2737
            branch_factory=make_stacked_stacked)
3170
2783
        super(TestRemoteBranchEffort, self).setUp()
3171
2784
        # Create a smart server that publishes whatever the backing VFS server
3172
2785
        # does.
3173
 
        self.smart_server = test_server.SmartTCPServer_for_testing()
3174
 
        self.start_server(self.smart_server, self.get_server())
 
2786
        self.smart_server = server.SmartTCPServer_for_testing()
 
2787
        self.smart_server.setUp(self.get_server())
 
2788
        self.addCleanup(self.smart_server.tearDown)
3175
2789
        # Log all HPSS calls into self.hpss_calls.
3176
2790
        _SmartClient.hooks.install_named_hook(
3177
2791
            'call', self.capture_hpss_call, None)