← 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-08-13 21:54:04 UTC
  • mto: This revision was merged to the branch mainline in revision 4629.
  • Revision ID: john@arbash-meinel.com-20090813215404-f1e6vemv7vxyivoe
Create the crude merge_sort implementation that just thunks over to the old implementation.
The main win here is that we get to copy across all the tests so far, and they all pass. :)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
1
 
# Copyright (C) 2006-2011 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
 
    graph as _mod_graph,
36
 
    inventory,
37
 
    inventory_delta,
 
33
    graph,
 
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,
56
49
    RemoteRepository,
57
50
    RemoteRepositoryFormat,
58
51
    )
59
 
from bzrlib.repofmt import groupcompress_repo, knitpack_repo
 
52
from bzrlib.repofmt import groupcompress_repo, pack_repo
60
53
from bzrlib.revision import NULL_REVISION
61
 
from bzrlib.smart import medium, request
 
54
from bzrlib.smart import server, medium
62
55
from bzrlib.smart.client import _SmartClient
63
 
from bzrlib.smart.repository import (
64
 
    SmartServerRepositoryGetParentMap,
65
 
    SmartServerRepositoryGetStream_1_19,
66
 
    )
 
56
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
67
57
from bzrlib.tests import (
68
 
    test_server,
 
58
    condition_isinstance,
 
59
    split_suite_by_condition,
 
60
    multiply_tests,
 
61
    KnownFailure,
69
62
    )
70
 
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
63
from bzrlib.transport import get_transport, http
71
64
from bzrlib.transport.memory import MemoryTransport
72
65
from bzrlib.transport.remote import (
73
66
    RemoteTransport,
74
67
    RemoteSSHTransport,
75
68
    RemoteTCPTransport,
76
 
    )
77
 
 
78
 
 
79
 
load_tests = load_tests_apply_scenarios
80
 
 
81
 
 
82
 
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
83
 
 
84
 
    scenarios = [
 
69
)
 
70
 
 
71
def load_tests(standard_tests, module, loader):
 
72
    to_adapt, result = split_suite_by_condition(
 
73
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
 
74
    smart_server_version_scenarios = [
85
75
        ('HPSS-v2',
86
 
            {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
 
76
            {'transport_server': server.SmartTCPServer_for_testing_v2_only}),
87
77
        ('HPSS-v3',
88
 
            {'transport_server': test_server.SmartTCPServer_for_testing})]
89
 
 
 
78
            {'transport_server': server.SmartTCPServer_for_testing})]
 
79
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
 
80
 
 
81
 
 
82
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
90
83
 
91
84
    def setUp(self):
92
85
        super(BasicRemoteObjectTests, self).setUp()
93
86
        self.transport = self.get_transport()
94
87
        # make a branch that can be opened over the smart transport
95
88
        self.local_wt = BzrDir.create_standalone_workingtree('.')
96
 
        self.addCleanup(self.transport.disconnect)
 
89
 
 
90
    def tearDown(self):
 
91
        self.transport.disconnect()
 
92
        tests.TestCaseWithTransport.tearDown(self)
97
93
 
98
94
    def test_create_remote_bzrdir(self):
99
 
        b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
 
95
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
100
96
        self.assertIsInstance(b, BzrDir)
101
97
 
102
98
    def test_open_remote_branch(self):
103
99
        # open a standalone branch in the working directory
104
 
        b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
 
100
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
105
101
        branch = b.open_branch()
106
102
        self.assertIsInstance(branch, Branch)
107
103
 
123
119
    def test_find_correct_format(self):
124
120
        """Should open a RemoteBzrDir over a RemoteTransport"""
125
121
        fmt = BzrDirFormat.find_format(self.transport)
126
 
        self.assertTrue(bzrdir.RemoteBzrProber
127
 
                        in controldir.ControlDirFormat._server_probers)
128
 
        self.assertIsInstance(fmt, RemoteBzrDirFormat)
 
122
        self.assertTrue(RemoteBzrDirFormat
 
123
                        in BzrDirFormat._control_server_formats)
 
124
        self.assertIsInstance(fmt, remote.RemoteBzrDirFormat)
129
125
 
130
126
    def test_open_detected_smart_format(self):
131
127
        fmt = BzrDirFormat.find_format(self.transport)
136
132
        b = BzrDir.open_from_transport(self.transport).open_branch()
137
133
        self.assertStartsWith(str(b), 'RemoteBranch(')
138
134
 
139
 
    def test_remote_bzrdir_repr(self):
140
 
        b = BzrDir.open_from_transport(self.transport)
141
 
        self.assertStartsWith(str(b), 'RemoteBzrDir(')
142
 
 
143
135
    def test_remote_branch_format_supports_stacking(self):
144
136
        t = self.transport
145
137
        self.make_branch('unstackable', format='pack-0.92')
285
277
        self.expecting_body = True
286
278
        return result[1], FakeProtocol(result[2], self)
287
279
 
288
 
    def call_with_body_bytes(self, method, args, body):
289
 
        self._check_call(method, args)
290
 
        self._calls.append(('call_with_body_bytes', method, args, body))
291
 
        result = self._get_next_response()
292
 
        return result[1], FakeProtocol(result[2], self)
293
 
 
294
280
    def call_with_body_bytes_expecting_body(self, method, args, body):
295
281
        self._check_call(method, args)
296
282
        self._calls.append(('call_with_body_bytes_expecting_body', method,
346
332
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
347
333
        return reference_bzrdir_format.repository_format
348
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
 
349
344
    def assertFinished(self, fake_client):
350
345
        """Assert that all of a FakeClient's expected calls have occurred."""
351
346
        fake_client.finished_test()
360
355
        a given client_base and transport_base.
361
356
        """
362
357
        client_medium = medium.SmartClientMedium(client_base)
363
 
        t = transport.get_transport(transport_base)
364
 
        result = client_medium.remote_path_from_transport(t)
 
358
        transport = get_transport(transport_base)
 
359
        result = client_medium.remote_path_from_transport(transport)
365
360
        self.assertEqual(expected, result)
366
361
 
367
362
    def test_remote_path_from_transport(self):
378
373
        a given transport_base and relpath of that transport.  (Note that
379
374
        HttpTransportBase is a subclass of SmartClientMedium)
380
375
        """
381
 
        base_transport = transport.get_transport(transport_base)
 
376
        base_transport = get_transport(transport_base)
382
377
        client_medium = base_transport.get_smart_medium()
383
378
        cloned_transport = base_transport.clone(relpath)
384
379
        result = client_medium.remote_path_from_transport(cloned_transport)
419
414
        # Calling _remember_remote_is_before again with a lower value works.
420
415
        client_medium._remember_remote_is_before((1, 5))
421
416
        self.assertTrue(client_medium._is_remote_before((1, 5)))
422
 
        # If you call _remember_remote_is_before with a higher value it logs a
423
 
        # warning, and continues to remember the lower value.
424
 
        self.assertNotContainsRe(self.get_log(), '_remember_remote_is_before')
425
 
        client_medium._remember_remote_is_before((1, 9))
426
 
        self.assertContainsRe(self.get_log(), '_remember_remote_is_before')
427
 
        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))
428
420
 
429
421
 
430
422
class TestBzrDirCloningMetaDir(TestRemote):
449
441
            'BzrDir.cloning_metadir', ('quack/', 'False'),
450
442
            'error', ('BranchReference',)),
451
443
        client.add_expected_call(
452
 
            'BzrDir.open_branchV3', ('quack/',),
 
444
            'BzrDir.open_branchV2', ('quack/',),
453
445
            'success', ('ref', self.get_url('referenced'))),
454
 
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
446
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
455
447
            _client=client)
456
448
        result = a_bzrdir.cloning_metadir()
457
449
        # We should have got a control dir matching the referenced branch.
470
462
        client.add_expected_call(
471
463
            'BzrDir.cloning_metadir', ('quack/', 'False'),
472
464
            'success', (control_name, '', ('branch', ''))),
473
 
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
465
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
474
466
            _client=client)
475
467
        result = a_bzrdir.cloning_metadir()
476
468
        # We should have got a reference control dir with default branch and
482
474
        self.assertFinished(client)
483
475
 
484
476
 
485
 
class TestBzrDirOpen(TestRemote):
486
 
 
487
 
    def make_fake_client_and_transport(self, path='quack'):
488
 
        transport = MemoryTransport()
489
 
        transport.mkdir(path)
490
 
        transport = transport.clone(path)
491
 
        client = FakeClient(transport.base)
492
 
        return client, transport
493
 
 
494
 
    def test_absent(self):
495
 
        client, transport = self.make_fake_client_and_transport()
496
 
        client.add_expected_call(
497
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
498
 
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
499
 
                RemoteBzrDirFormat(), _client=client, _force_probe=True)
500
 
        self.assertFinished(client)
501
 
 
502
 
    def test_present_without_workingtree(self):
503
 
        client, transport = self.make_fake_client_and_transport()
504
 
        client.add_expected_call(
505
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
506
 
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
507
 
            _client=client, _force_probe=True)
508
 
        self.assertIsInstance(bd, RemoteBzrDir)
509
 
        self.assertFalse(bd.has_workingtree())
510
 
        self.assertRaises(errors.NoWorkingTree, bd.open_workingtree)
511
 
        self.assertFinished(client)
512
 
 
513
 
    def test_present_with_workingtree(self):
514
 
        client, transport = self.make_fake_client_and_transport()
515
 
        client.add_expected_call(
516
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
517
 
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
518
 
            _client=client, _force_probe=True)
519
 
        self.assertIsInstance(bd, RemoteBzrDir)
520
 
        self.assertTrue(bd.has_workingtree())
521
 
        self.assertRaises(errors.NotLocalUrl, bd.open_workingtree)
522
 
        self.assertFinished(client)
523
 
 
524
 
    def test_backwards_compat(self):
525
 
        client, transport = self.make_fake_client_and_transport()
526
 
        client.add_expected_call(
527
 
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
528
 
        client.add_expected_call(
529
 
            'BzrDir.open', ('quack/',), 'success', ('yes',))
530
 
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
531
 
            _client=client, _force_probe=True)
532
 
        self.assertIsInstance(bd, RemoteBzrDir)
533
 
        self.assertFinished(client)
534
 
 
535
 
    def test_backwards_compat_hpss_v2(self):
536
 
        client, transport = self.make_fake_client_and_transport()
537
 
        # Monkey-patch fake client to simulate real-world behaviour with v2
538
 
        # server: upon first RPC call detect the protocol version, and because
539
 
        # the version is 2 also do _remember_remote_is_before((1, 6)) before
540
 
        # continuing with the RPC.
541
 
        orig_check_call = client._check_call
542
 
        def check_call(method, args):
543
 
            client._medium._protocol_version = 2
544
 
            client._medium._remember_remote_is_before((1, 6))
545
 
            client._check_call = orig_check_call
546
 
            client._check_call(method, args)
547
 
        client._check_call = check_call
548
 
        client.add_expected_call(
549
 
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
550
 
        client.add_expected_call(
551
 
            'BzrDir.open', ('quack/',), 'success', ('yes',))
552
 
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
553
 
            _client=client, _force_probe=True)
554
 
        self.assertIsInstance(bd, RemoteBzrDir)
555
 
        self.assertFinished(client)
556
 
 
557
 
 
558
477
class TestBzrDirOpenBranch(TestRemote):
559
478
 
560
479
    def test_backwards_compat(self):
562
481
        self.make_branch('.')
563
482
        a_dir = BzrDir.open(self.get_url('.'))
564
483
        self.reset_smart_call_log()
565
 
        verb = 'BzrDir.open_branchV3'
 
484
        verb = 'BzrDir.open_branchV2'
566
485
        self.disable_verb(verb)
567
486
        format = a_dir.open_branch()
568
487
        call_count = len([call for call in self.hpss_calls if
578
497
        transport = transport.clone('quack')
579
498
        client = FakeClient(transport.base)
580
499
        client.add_expected_call(
581
 
            'BzrDir.open_branchV3', ('quack/',),
 
500
            'BzrDir.open_branchV2', ('quack/',),
582
501
            'success', ('branch', branch_network_name))
583
502
        client.add_expected_call(
584
503
            'BzrDir.find_repositoryV3', ('quack/',),
586
505
        client.add_expected_call(
587
506
            'Branch.get_stacked_on_url', ('quack/',),
588
507
            'error', ('NotStacked',))
589
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
508
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
590
509
            _client=client)
591
510
        result = bzrdir.open_branch()
592
511
        self.assertIsInstance(result, RemoteBranch)
599
518
        transport = transport.clone('quack')
600
519
        client = FakeClient(transport.base)
601
520
        client.add_error_response('nobranch')
602
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
521
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
603
522
            _client=client)
604
523
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
605
524
        self.assertEqual(
606
 
            [('call', 'BzrDir.open_branchV3', ('quack/',))],
 
525
            [('call', 'BzrDir.open_branchV2', ('quack/',))],
607
526
            client._calls)
608
527
 
609
528
    def test__get_tree_branch(self):
610
529
        # _get_tree_branch is a form of open_branch, but it should only ask for
611
530
        # branch opening, not any other network requests.
612
531
        calls = []
613
 
        def open_branch(name=None):
 
532
        def open_branch():
614
533
            calls.append("Called")
615
534
            return "a-branch"
616
535
        transport = MemoryTransport()
617
536
        # no requests on the network - catches other api calls being made.
618
537
        client = FakeClient(transport.base)
619
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
538
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
620
539
            _client=client)
621
540
        # patch the open_branch call to record that it was called.
622
541
        bzrdir.open_branch = open_branch
633
552
        network_name = reference_format.network_name()
634
553
        branch_network_name = self.get_branch_format().network_name()
635
554
        client.add_expected_call(
636
 
            'BzrDir.open_branchV3', ('~hello/',),
 
555
            'BzrDir.open_branchV2', ('~hello/',),
637
556
            'success', ('branch', branch_network_name))
638
557
        client.add_expected_call(
639
558
            'BzrDir.find_repositoryV3', ('~hello/',),
641
560
        client.add_expected_call(
642
561
            'Branch.get_stacked_on_url', ('~hello/',),
643
562
            'error', ('NotStacked',))
644
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
563
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
645
564
            _client=client)
646
565
        result = bzrdir.open_branch()
647
566
        self.assertFinished(client)
664
583
        client.add_success_response(
665
584
            'ok', '', rich_response, subtree_response, external_lookup,
666
585
            network_name)
667
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
586
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
668
587
            _client=client)
669
588
        result = bzrdir.open_repository()
670
589
        self.assertEqual(
687
606
        old.
688
607
        """
689
608
        self.assertRaises(errors.NotBranchError,
690
 
            RemoteBzrProber.probe_transport, OldServerTransport())
 
609
            RemoteBzrDirFormat.probe_transport, OldServerTransport())
691
610
 
692
611
 
693
612
class TestBzrDirCreateBranch(TestRemote):
716
635
            'BzrDir.create_branch', ('quack/', network_name),
717
636
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
718
637
            reference_repo_name))
719
 
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
638
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
720
639
            _client=client)
721
640
        branch = a_bzrdir.create_branch()
722
641
        # We should have got a remote branch
725
644
        format = branch._format
726
645
        self.assertEqual(network_name, format.network_name())
727
646
 
728
 
    def test_already_open_repo_and_reused_medium(self):
729
 
        """Bug 726584: create_branch(..., repository=repo) should work
730
 
        regardless of what the smart medium's base URL is.
731
 
        """
732
 
        self.transport_server = test_server.SmartTCPServer_for_testing
733
 
        transport = self.get_transport('.')
734
 
        repo = self.make_repository('quack')
735
 
        # Client's medium rooted a transport root (not at the bzrdir)
736
 
        client = FakeClient(transport.base)
737
 
        transport = transport.clone('quack')
738
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
739
 
        reference_format = reference_bzrdir_format.get_branch_format()
740
 
        network_name = reference_format.network_name()
741
 
        reference_repo_fmt = reference_bzrdir_format.repository_format
742
 
        reference_repo_name = reference_repo_fmt.network_name()
743
 
        client.add_expected_call(
744
 
            'BzrDir.create_branch', ('extra/quack/', network_name),
745
 
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
746
 
            reference_repo_name))
747
 
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
748
 
            _client=client)
749
 
        branch = a_bzrdir.create_branch(repository=repo)
750
 
        # We should have got a remote branch
751
 
        self.assertIsInstance(branch, remote.RemoteBranch)
752
 
        # its format should have the settings from the response
753
 
        format = branch._format
754
 
        self.assertEqual(network_name, format.network_name())
755
 
 
756
647
 
757
648
class TestBzrDirCreateRepository(TestRemote):
758
649
 
776
667
        network_name = reference_format.network_name()
777
668
        client.add_expected_call(
778
669
            'BzrDir.create_repository', ('quack/',
779
 
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
780
 
                'False'),
781
 
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
782
 
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
670
                'Bazaar pack repository format 1 (needs bzr 0.92)\n', 'False'),
 
671
            'success', ('ok', 'no', 'no', 'no', network_name))
 
672
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
783
673
            _client=client)
784
674
        repo = a_bzrdir.create_repository()
785
675
        # We should have got a remote repository
786
676
        self.assertIsInstance(repo, remote.RemoteRepository)
787
677
        # its format should have the settings from the response
788
678
        format = repo._format
789
 
        self.assertTrue(format.rich_root_data)
790
 
        self.assertTrue(format.supports_tree_reference)
791
 
        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)
792
682
        self.assertEqual(network_name, format.network_name())
793
683
 
794
684
 
798
688
        # fallback all the way to the first version.
799
689
        reference_format = self.get_repo_format()
800
690
        network_name = reference_format.network_name()
801
 
        server_url = 'bzr://example.com/'
802
 
        self.permit_url(server_url)
803
 
        client = FakeClient(server_url)
 
691
        client = FakeClient('bzr://example.com/')
804
692
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
805
693
        client.add_unknown_method_response('BzrDir.find_repositoryV2')
806
694
        client.add_success_response('ok', '', 'no', 'no')
812
700
            reference_format.get_format_string(), 'ok')
813
701
        # PackRepository wants to do a stat
814
702
        client.add_success_response('stat', '0', '65535')
815
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
703
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
816
704
            _client=client)
817
 
        bzrdir = RemoteBzrDir(remote_transport, RemoteBzrDirFormat(),
 
705
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
818
706
            _client=client)
819
707
        repo = bzrdir.open_repository()
820
708
        self.assertEqual(
832
720
        # fallback to find_repositoryV2
833
721
        reference_format = self.get_repo_format()
834
722
        network_name = reference_format.network_name()
835
 
        server_url = 'bzr://example.com/'
836
 
        self.permit_url(server_url)
837
 
        client = FakeClient(server_url)
 
723
        client = FakeClient('bzr://example.com/')
838
724
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
839
725
        client.add_success_response('ok', '', 'no', 'no', 'no')
840
726
        # A real repository instance will be created to determine the network
845
731
            reference_format.get_format_string(), 'ok')
846
732
        # PackRepository wants to do a stat
847
733
        client.add_success_response('stat', '0', '65535')
848
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
734
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
849
735
            _client=client)
850
 
        bzrdir = RemoteBzrDir(remote_transport, RemoteBzrDirFormat(),
 
736
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
851
737
            _client=client)
852
738
        repo = bzrdir.open_repository()
853
739
        self.assertEqual(
868
754
        transport = transport.clone('quack')
869
755
        client = FakeClient(transport.base)
870
756
        client.add_success_response('ok', '', 'no', 'no', 'no', network_name)
871
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
757
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
872
758
            _client=client)
873
759
        repo = bzrdir.open_repository()
874
760
        self.assertEqual(
881
767
 
882
768
    def test_success(self):
883
769
        """Simple test for typical successful call."""
884
 
        fmt = RemoteBzrDirFormat()
 
770
        fmt = bzrdir.RemoteBzrDirFormat()
885
771
        default_format_name = BzrDirFormat.get_default_format().network_name()
886
772
        transport = self.get_transport()
887
773
        client = FakeClient(transport.base)
903
789
        """Error responses are translated, e.g. 'PermissionDenied' raises the
904
790
        corresponding error from the client.
905
791
        """
906
 
        fmt = RemoteBzrDirFormat()
 
792
        fmt = bzrdir.RemoteBzrDirFormat()
907
793
        default_format_name = BzrDirFormat.get_default_format().network_name()
908
794
        transport = self.get_transport()
909
795
        client = FakeClient(transport.base)
927
813
        """Integration test for error translation."""
928
814
        transport = self.make_smart_server('foo')
929
815
        transport = transport.clone('no-such-path')
930
 
        fmt = RemoteBzrDirFormat()
 
816
        fmt = bzrdir.RemoteBzrDirFormat()
931
817
        err = self.assertRaises(errors.NoSuchFile,
932
818
            fmt.initialize_on_transport_ex, transport, create_prefix=False)
933
819
 
964
850
 
965
851
    def make_remote_bzrdir(self, transport, client):
966
852
        """Make a RemotebzrDir using 'client' as the _client."""
967
 
        return RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
853
        return RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
968
854
            _client=client)
969
855
 
970
856
 
971
857
class RemoteBranchTestCase(RemoteBzrDirTestCase):
972
858
 
973
 
    def lock_remote_branch(self, branch):
974
 
        """Trick a RemoteBranch into thinking it is locked."""
975
 
        branch._lock_mode = 'w'
976
 
        branch._lock_count = 2
977
 
        branch._lock_token = 'branch token'
978
 
        branch._repo_lock_token = 'repo token'
979
 
        branch.repository._lock_mode = 'w'
980
 
        branch.repository._lock_count = 2
981
 
        branch.repository._lock_token = 'repo token'
982
 
 
983
859
    def make_remote_branch(self, transport, client):
984
860
        """Make a RemoteBranch using 'client' as its _SmartClient.
985
861
 
1124
1000
        self.assertEqual({}, result)
1125
1001
 
1126
1002
 
1127
 
class TestBranchSetTagsBytes(RemoteBranchTestCase):
1128
 
 
1129
 
    def test_trivial(self):
1130
 
        transport = MemoryTransport()
1131
 
        client = FakeClient(transport.base)
1132
 
        client.add_expected_call(
1133
 
            'Branch.get_stacked_on_url', ('quack/',),
1134
 
            'error', ('NotStacked',))
1135
 
        client.add_expected_call(
1136
 
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1137
 
            'success', ('',))
1138
 
        transport.mkdir('quack')
1139
 
        transport = transport.clone('quack')
1140
 
        branch = self.make_remote_branch(transport, client)
1141
 
        self.lock_remote_branch(branch)
1142
 
        branch._set_tags_bytes('tags bytes')
1143
 
        self.assertFinished(client)
1144
 
        self.assertEqual('tags bytes', client._calls[-1][-1])
1145
 
 
1146
 
    def test_backwards_compatible(self):
1147
 
        transport = MemoryTransport()
1148
 
        client = FakeClient(transport.base)
1149
 
        client.add_expected_call(
1150
 
            'Branch.get_stacked_on_url', ('quack/',),
1151
 
            'error', ('NotStacked',))
1152
 
        client.add_expected_call(
1153
 
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1154
 
            'unknown', ('Branch.set_tags_bytes',))
1155
 
        transport.mkdir('quack')
1156
 
        transport = transport.clone('quack')
1157
 
        branch = self.make_remote_branch(transport, client)
1158
 
        self.lock_remote_branch(branch)
1159
 
        class StubRealBranch(object):
1160
 
            def __init__(self):
1161
 
                self.calls = []
1162
 
            def _set_tags_bytes(self, bytes):
1163
 
                self.calls.append(('set_tags_bytes', bytes))
1164
 
        real_branch = StubRealBranch()
1165
 
        branch._real_branch = real_branch
1166
 
        branch._set_tags_bytes('tags bytes')
1167
 
        # Call a second time, to exercise the 'remote version already inferred'
1168
 
        # code path.
1169
 
        branch._set_tags_bytes('tags bytes')
1170
 
        self.assertFinished(client)
1171
 
        self.assertEqual(
1172
 
            [('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1173
 
 
1174
 
 
1175
 
class TestBranchHeadsToFetch(RemoteBranchTestCase):
1176
 
 
1177
 
    def test_uses_last_revision_info_and_tags_by_default(self):
1178
 
        transport = MemoryTransport()
1179
 
        client = FakeClient(transport.base)
1180
 
        client.add_expected_call(
1181
 
            'Branch.get_stacked_on_url', ('quack/',),
1182
 
            'error', ('NotStacked',))
1183
 
        client.add_expected_call(
1184
 
            'Branch.last_revision_info', ('quack/',),
1185
 
            'success', ('ok', '1', 'rev-tip'))
1186
 
        # XXX: this will break if the default format's serialization of tags
1187
 
        # changes, or if the RPC for fetching tags changes from get_tags_bytes.
1188
 
        client.add_expected_call(
1189
 
            'Branch.get_tags_bytes', ('quack/',),
1190
 
            'success', ('d5:tag-17:rev-foo5:tag-27:rev-bare',))
1191
 
        transport.mkdir('quack')
1192
 
        transport = transport.clone('quack')
1193
 
        branch = self.make_remote_branch(transport, client)
1194
 
        result = branch.heads_to_fetch()
1195
 
        self.assertFinished(client)
1196
 
        self.assertEqual(
1197
 
            (set(['rev-tip']), set(['rev-foo', 'rev-bar'])), result)
1198
 
 
1199
 
    def test_uses_rpc_for_formats_with_non_default_heads_to_fetch(self):
1200
 
        transport = MemoryTransport()
1201
 
        client = FakeClient(transport.base)
1202
 
        client.add_expected_call(
1203
 
            'Branch.get_stacked_on_url', ('quack/',),
1204
 
            'error', ('NotStacked',))
1205
 
        client.add_expected_call(
1206
 
            'Branch.heads_to_fetch', ('quack/',),
1207
 
            'success', (['tip'], ['tagged-1', 'tagged-2']))
1208
 
        transport.mkdir('quack')
1209
 
        transport = transport.clone('quack')
1210
 
        branch = self.make_remote_branch(transport, client)
1211
 
        branch._format._use_default_local_heads_to_fetch = lambda: False
1212
 
        result = branch.heads_to_fetch()
1213
 
        self.assertFinished(client)
1214
 
        self.assertEqual((set(['tip']), set(['tagged-1', 'tagged-2'])), result)
1215
 
 
1216
 
    def test_backwards_compatible(self):
1217
 
        self.setup_smart_server_with_call_log()
1218
 
        # Make a branch with a single revision.
1219
 
        builder = self.make_branch_builder('foo')
1220
 
        builder.start_series()
1221
 
        builder.build_snapshot('tip', None, [
1222
 
            ('add', ('', 'root-id', 'directory', ''))])
1223
 
        builder.finish_series()
1224
 
        branch = builder.get_branch()
1225
 
        # Add two tags to that branch
1226
 
        branch.tags.set_tag('tag-1', 'rev-1')
1227
 
        branch.tags.set_tag('tag-2', 'rev-2')
1228
 
        self.addCleanup(branch.lock_read().unlock)
1229
 
        # Disable the heads_to_fetch verb
1230
 
        verb = 'Branch.heads_to_fetch'
1231
 
        self.disable_verb(verb)
1232
 
        self.reset_smart_call_log()
1233
 
        result = branch.heads_to_fetch()
1234
 
        self.assertEqual((set(['tip']), set(['rev-1', 'rev-2'])), result)
1235
 
        self.assertEqual(
1236
 
            ['Branch.last_revision_info', 'Branch.get_tags_bytes'],
1237
 
            [call.call.method for call in self.hpss_calls])
1238
 
 
1239
 
 
1240
1003
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1241
1004
 
1242
1005
    def test_empty_branch(self):
1297
1060
        client.add_expected_call(
1298
1061
            'Branch.get_stacked_on_url', ('stacked/',),
1299
1062
            'success', ('ok', vfs_url))
1300
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
1063
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
1301
1064
            _client=client)
1302
1065
        repo_fmt = remote.RemoteRepositoryFormat()
1303
1066
        repo_fmt._custom_format = stacked_branch.repository._format
1314
1077
        client = FakeClient(self.get_url())
1315
1078
        branch_network_name = self.get_branch_format().network_name()
1316
1079
        client.add_expected_call(
1317
 
            'BzrDir.open_branchV3', ('stacked/',),
 
1080
            'BzrDir.open_branchV2', ('stacked/',),
1318
1081
            'success', ('branch', branch_network_name))
1319
1082
        client.add_expected_call(
1320
1083
            'BzrDir.find_repositoryV3', ('stacked/',),
1330
1093
        # this will also do vfs access, but that goes direct to the transport
1331
1094
        # and isn't seen by the FakeClient.
1332
1095
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1333
 
            RemoteBzrDirFormat(), _client=client)
 
1096
            remote.RemoteBzrDirFormat(), _client=client)
1334
1097
        branch = bzrdir.open_branch()
1335
1098
        result = branch.get_stacked_on_url()
1336
1099
        self.assertEqual('../base', result)
1342
1105
            len(branch.repository._real_repository._fallback_repositories))
1343
1106
 
1344
1107
    def test_get_stacked_on_real_branch(self):
1345
 
        base_branch = self.make_branch('base')
1346
 
        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')
1347
1110
        stacked_branch.set_stacked_on_url('../base')
1348
1111
        reference_format = self.get_repo_format()
1349
1112
        network_name = reference_format.network_name()
1350
1113
        client = FakeClient(self.get_url())
1351
1114
        branch_network_name = self.get_branch_format().network_name()
1352
1115
        client.add_expected_call(
1353
 
            'BzrDir.open_branchV3', ('stacked/',),
 
1116
            'BzrDir.open_branchV2', ('stacked/',),
1354
1117
            'success', ('branch', branch_network_name))
1355
1118
        client.add_expected_call(
1356
1119
            'BzrDir.find_repositoryV3', ('stacked/',),
1357
 
            'success', ('ok', '', 'yes', 'no', 'yes', network_name))
 
1120
            'success', ('ok', '', 'no', 'no', 'yes', network_name))
1358
1121
        # called twice, once from constructor and then again by us
1359
1122
        client.add_expected_call(
1360
1123
            'Branch.get_stacked_on_url', ('stacked/',),
1363
1126
            'Branch.get_stacked_on_url', ('stacked/',),
1364
1127
            'success', ('ok', '../base'))
1365
1128
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1366
 
            RemoteBzrDirFormat(), _client=client)
 
1129
            remote.RemoteBzrDirFormat(), _client=client)
1367
1130
        branch = bzrdir.open_branch()
1368
1131
        result = branch.get_stacked_on_url()
1369
1132
        self.assertEqual('../base', result)
1377
1140
class TestBranchSetLastRevision(RemoteBranchTestCase):
1378
1141
 
1379
1142
    def test_set_empty(self):
1380
 
        # _set_last_revision_info('null:') is translated to calling
 
1143
        # set_revision_history([]) is translated to calling
1381
1144
        # Branch.set_last_revision(path, '') on the wire.
1382
1145
        transport = MemoryTransport()
1383
1146
        transport.mkdir('branch')
1405
1168
        # unnecessarily invokes _ensure_real upon a call to lock_write.
1406
1169
        branch._ensure_real = lambda: None
1407
1170
        branch.lock_write()
1408
 
        result = branch._set_last_revision(NULL_REVISION)
 
1171
        result = branch.set_revision_history([])
1409
1172
        branch.unlock()
1410
1173
        self.assertEqual(None, result)
1411
1174
        self.assertFinished(client)
1412
1175
 
1413
1176
    def test_set_nonempty(self):
1414
 
        # set_last_revision_info(N, rev-idN) is translated to calling
 
1177
        # set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
1415
1178
        # Branch.set_last_revision(path, rev-idN) on the wire.
1416
1179
        transport = MemoryTransport()
1417
1180
        transport.mkdir('branch')
1443
1206
        branch._ensure_real = lambda: None
1444
1207
        # Lock the branch, reset the record of remote calls.
1445
1208
        branch.lock_write()
1446
 
        result = branch._set_last_revision('rev-id2')
 
1209
        result = branch.set_revision_history(['rev-id1', 'rev-id2'])
1447
1210
        branch.unlock()
1448
1211
        self.assertEqual(None, result)
1449
1212
        self.assertFinished(client)
1479
1242
        branch = self.make_remote_branch(transport, client)
1480
1243
        branch.lock_write()
1481
1244
        self.assertRaises(
1482
 
            errors.NoSuchRevision, branch._set_last_revision, 'rev-id')
 
1245
            errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
1483
1246
        branch.unlock()
1484
1247
        self.assertFinished(client)
1485
1248
 
1516
1279
        branch._ensure_real = lambda: None
1517
1280
        branch.lock_write()
1518
1281
        # The 'TipChangeRejected' error response triggered by calling
1519
 
        # set_last_revision_info causes a TipChangeRejected exception.
 
1282
        # set_revision_history causes a TipChangeRejected exception.
1520
1283
        err = self.assertRaises(
1521
 
            errors.TipChangeRejected,
1522
 
            branch._set_last_revision, 'rev-id')
 
1284
            errors.TipChangeRejected, branch.set_revision_history, ['rev-id'])
1523
1285
        # The UTF-8 message from the response has been decoded into a unicode
1524
1286
        # object.
1525
1287
        self.assertIsInstance(err.msg, unicode)
1585
1347
            errors.NoSuchRevision, branch.set_last_revision_info, 123, 'revid')
1586
1348
        branch.unlock()
1587
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
 
1588
1360
    def test_backwards_compatibility(self):
1589
1361
        """If the server does not support the Branch.set_last_revision_info
1590
1362
        verb (which is new in 1.4), then the client falls back to VFS methods.
1713
1485
    def test_get_multi_line_branch_conf(self):
1714
1486
        # Make sure that multiple-line branch.conf files are supported
1715
1487
        #
1716
 
        # https://bugs.launchpad.net/bzr/+bug/354075
 
1488
        # https://bugs.edge.launchpad.net/bzr/+bug/354075
1717
1489
        client = FakeClient()
1718
1490
        client.add_expected_call(
1719
1491
            'Branch.get_stacked_on_url', ('memory:///',),
1747
1519
        branch.unlock()
1748
1520
        self.assertFinished(client)
1749
1521
 
1750
 
    def test_set_option_with_dict(self):
1751
 
        client = FakeClient()
1752
 
        client.add_expected_call(
1753
 
            'Branch.get_stacked_on_url', ('memory:///',),
1754
 
            'error', ('NotStacked',),)
1755
 
        client.add_expected_call(
1756
 
            'Branch.lock_write', ('memory:///', '', ''),
1757
 
            'success', ('ok', 'branch token', 'repo token'))
1758
 
        encoded_dict_value = 'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde'
1759
 
        client.add_expected_call(
1760
 
            'Branch.set_config_option_dict', ('memory:///', 'branch token',
1761
 
            'repo token', encoded_dict_value, 'foo', ''),
1762
 
            'success', ())
1763
 
        client.add_expected_call(
1764
 
            'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
1765
 
            'success', ('ok',))
1766
 
        transport = MemoryTransport()
1767
 
        branch = self.make_remote_branch(transport, client)
1768
 
        branch.lock_write()
1769
 
        config = branch._get_config()
1770
 
        config.set_option(
1771
 
            {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'},
1772
 
            'foo')
1773
 
        branch.unlock()
1774
 
        self.assertFinished(client)
1775
 
 
1776
1522
    def test_backwards_compat_set_option(self):
1777
1523
        self.setup_smart_server_with_call_log()
1778
1524
        branch = self.make_branch('.')
1785
1531
        self.assertLength(10, self.hpss_calls)
1786
1532
        self.assertEqual('value', branch._get_config().get_option('name'))
1787
1533
 
1788
 
    def test_backwards_compat_set_option_with_dict(self):
1789
 
        self.setup_smart_server_with_call_log()
1790
 
        branch = self.make_branch('.')
1791
 
        verb = 'Branch.set_config_option_dict'
1792
 
        self.disable_verb(verb)
1793
 
        branch.lock_write()
1794
 
        self.addCleanup(branch.unlock)
1795
 
        self.reset_smart_call_log()
1796
 
        config = branch._get_config()
1797
 
        value_dict = {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
1798
 
        config.set_option(value_dict, 'name')
1799
 
        self.assertLength(10, self.hpss_calls)
1800
 
        self.assertEqual(value_dict, branch._get_config().get_option('name'))
1801
 
 
1802
1534
 
1803
1535
class TestBranchLockWrite(RemoteBranchTestCase):
1804
1536
 
1940
1672
        client = FakeClient(transport.base)
1941
1673
        transport = transport.clone(transport_path)
1942
1674
        # we do not want bzrdir to make any remote calls
1943
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
1675
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
1944
1676
            _client=False)
1945
1677
        repo = RemoteRepository(bzrdir, None, _client=client)
1946
1678
        return repo, client
1947
1679
 
1948
1680
 
1949
 
def remoted_description(format):
1950
 
    return 'Remote: ' + format.get_format_description()
1951
 
 
1952
 
 
1953
 
class TestBranchFormat(tests.TestCase):
1954
 
 
1955
 
    def test_get_format_description(self):
1956
 
        remote_format = RemoteBranchFormat()
1957
 
        real_format = branch.format_registry.get_default()
1958
 
        remote_format._network_name = real_format.network_name()
1959
 
        self.assertEqual(remoted_description(real_format),
1960
 
            remote_format.get_format_description())
1961
 
 
1962
 
 
1963
1681
class TestRepositoryFormat(TestRemoteRepository):
1964
1682
 
1965
1683
    def test_fast_delta(self):
1966
 
        true_name = groupcompress_repo.RepositoryFormat2a().network_name()
 
1684
        true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
1967
1685
        true_format = RemoteRepositoryFormat()
1968
1686
        true_format._network_name = true_name
1969
1687
        self.assertEqual(True, true_format.fast_deltas)
1970
 
        false_name = knitpack_repo.RepositoryFormatKnitPack1().network_name()
 
1688
        false_name = pack_repo.RepositoryFormatKnitPack1().network_name()
1971
1689
        false_format = RemoteRepositoryFormat()
1972
1690
        false_format._network_name = false_name
1973
1691
        self.assertEqual(False, false_format.fast_deltas)
1974
1692
 
1975
 
    def test_get_format_description(self):
1976
 
        remote_repo_format = RemoteRepositoryFormat()
1977
 
        real_format = repository.format_registry.get_default()
1978
 
        remote_repo_format._network_name = real_format.network_name()
1979
 
        self.assertEqual(remoted_description(real_format),
1980
 
            remote_repo_format.get_format_description())
1981
 
 
1982
1693
 
1983
1694
class TestRepositoryGatherStats(TestRemoteRepository):
1984
1695
 
2169
1880
        self.assertLength(1, self.hpss_calls)
2170
1881
 
2171
1882
    def disableExtraResults(self):
2172
 
        self.overrideAttr(SmartServerRepositoryGetParentMap,
2173
 
                          '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)
2174
1888
 
2175
1889
    def test_null_cached_missing_and_stop_key(self):
2176
1890
        self.setup_smart_server_with_call_log()
2235
1949
 
2236
1950
    def test_allows_new_revisions(self):
2237
1951
        """get_parent_map's results can be updated by commit."""
2238
 
        smart_server = test_server.SmartTCPServer_for_testing()
2239
 
        self.start_server(smart_server)
 
1952
        smart_server = server.SmartTCPServer_for_testing()
 
1953
        smart_server.setUp()
 
1954
        self.addCleanup(smart_server.tearDown)
2240
1955
        self.make_branch('branch')
2241
1956
        branch = Branch.open(smart_server.get_url() + '/branch')
2242
1957
        tree = branch.create_checkout('tree', lightweight=True)
2351
2066
        """
2352
2067
        # Make a repo with a fallback repo, both using a FakeClient.
2353
2068
        format = remote.response_tuple_to_repo_format(
2354
 
            ('yes', 'no', 'yes', self.get_repo_format().network_name()))
 
2069
            ('yes', 'no', 'yes', 'fake-network-name'))
2355
2070
        repo, client = self.setup_fake_client_and_repository('quack')
2356
2071
        repo._format = format
2357
2072
        fallback_repo, ignored = self.setup_fake_client_and_repository(
2358
2073
            'fallback')
2359
2074
        fallback_repo._client = client
2360
 
        fallback_repo._format = format
2361
2075
        repo.add_fallback_repository(fallback_repo)
2362
2076
        # First the client should ask the primary repo
2363
2077
        client.add_expected_call(
2384
2098
            repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
2385
2099
        self.assertFinished(client)
2386
2100
 
2387
 
    def test_branch_fallback_locking(self):
2388
 
        """RemoteBranch.get_rev_id takes a read lock, and tries to call the
2389
 
        get_rev_id_for_revno verb.  If the verb is unknown the VFS fallback
2390
 
        will be invoked, which will fail if the repo is unlocked.
2391
 
        """
2392
 
        self.setup_smart_server_with_call_log()
2393
 
        tree = self.make_branch_and_memory_tree('.')
2394
 
        tree.lock_write()
2395
 
        tree.add('')
2396
 
        rev1 = tree.commit('First')
2397
 
        rev2 = tree.commit('Second')
2398
 
        tree.unlock()
2399
 
        branch = tree.branch
2400
 
        self.assertFalse(branch.is_locked())
2401
 
        self.reset_smart_call_log()
2402
 
        verb = 'Repository.get_rev_id_for_revno'
2403
 
        self.disable_verb(verb)
2404
 
        self.assertEqual(rev1, branch.get_rev_id(1))
2405
 
        self.assertLength(1, [call for call in self.hpss_calls if
2406
 
                              call.call.method == verb])
2407
 
 
2408
2101
 
2409
2102
class TestRepositoryIsShared(TestRemoteRepository):
2410
2103
 
2437
2130
        transport_path = 'quack'
2438
2131
        repo, client = self.setup_fake_client_and_repository(transport_path)
2439
2132
        client.add_success_response('ok', 'a token')
2440
 
        token = repo.lock_write().repository_token
 
2133
        result = repo.lock_write()
2441
2134
        self.assertEqual(
2442
2135
            [('call', 'Repository.lock_write', ('quack/', ''))],
2443
2136
            client._calls)
2444
 
        self.assertEqual('a token', token)
 
2137
        self.assertEqual('a token', result)
2445
2138
 
2446
2139
    def test_lock_write_already_locked(self):
2447
2140
        transport_path = 'quack'
2526
2219
        self.assertEqual([], client._calls)
2527
2220
 
2528
2221
 
2529
 
class TestRepositoryInsertStreamBase(TestRemoteRepository):
2530
 
    """Base class for Repository.insert_stream and .insert_stream_1.19
2531
 
    tests.
2532
 
    """
2533
 
    
2534
 
    def checkInsertEmptyStream(self, repo, client):
2535
 
        """Insert an empty stream, checking the result.
2536
 
 
2537
 
        This checks that there are no resume_tokens or missing_keys, and that
2538
 
        the client is finished.
2539
 
        """
2540
 
        sink = repo._get_sink()
2541
 
        fmt = repository.format_registry.get_default()
2542
 
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2543
 
        self.assertEqual([], resume_tokens)
2544
 
        self.assertEqual(set(), missing_keys)
2545
 
        self.assertFinished(client)
2546
 
 
2547
 
 
2548
 
class TestRepositoryInsertStream(TestRepositoryInsertStreamBase):
2549
 
    """Tests for using Repository.insert_stream verb when the _1.19 variant is
2550
 
    not available.
2551
 
 
2552
 
    This test case is very similar to TestRepositoryInsertStream_1_19.
2553
 
    """
2554
 
 
2555
 
    def setUp(self):
2556
 
        TestRemoteRepository.setUp(self)
2557
 
        self.disable_verb('Repository.insert_stream_1.19')
2558
 
 
2559
 
    def test_unlocked_repo(self):
2560
 
        transport_path = 'quack'
2561
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2562
 
        client.add_expected_call(
2563
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2564
 
            'unknown', ('Repository.insert_stream_1.19',))
2565
 
        client.add_expected_call(
2566
 
            'Repository.insert_stream', ('quack/', ''),
2567
 
            'success', ('ok',))
2568
 
        client.add_expected_call(
2569
 
            'Repository.insert_stream', ('quack/', ''),
2570
 
            'success', ('ok',))
2571
 
        self.checkInsertEmptyStream(repo, client)
2572
 
 
2573
 
    def test_locked_repo_with_no_lock_token(self):
2574
 
        transport_path = 'quack'
2575
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2576
 
        client.add_expected_call(
2577
 
            'Repository.lock_write', ('quack/', ''),
2578
 
            'success', ('ok', ''))
2579
 
        client.add_expected_call(
2580
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2581
 
            'unknown', ('Repository.insert_stream_1.19',))
2582
 
        client.add_expected_call(
2583
 
            'Repository.insert_stream', ('quack/', ''),
2584
 
            'success', ('ok',))
2585
 
        client.add_expected_call(
2586
 
            'Repository.insert_stream', ('quack/', ''),
2587
 
            'success', ('ok',))
2588
 
        repo.lock_write()
2589
 
        self.checkInsertEmptyStream(repo, client)
2590
 
 
2591
 
    def test_locked_repo_with_lock_token(self):
2592
 
        transport_path = 'quack'
2593
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2594
 
        client.add_expected_call(
2595
 
            'Repository.lock_write', ('quack/', ''),
2596
 
            'success', ('ok', 'a token'))
2597
 
        client.add_expected_call(
2598
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2599
 
            'unknown', ('Repository.insert_stream_1.19',))
2600
 
        client.add_expected_call(
2601
 
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2602
 
            'success', ('ok',))
2603
 
        client.add_expected_call(
2604
 
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2605
 
            'success', ('ok',))
2606
 
        repo.lock_write()
2607
 
        self.checkInsertEmptyStream(repo, client)
2608
 
 
2609
 
    def test_stream_with_inventory_deltas(self):
2610
 
        """'inventory-deltas' substreams cannot be sent to the
2611
 
        Repository.insert_stream verb, because not all servers that implement
2612
 
        that verb will accept them.  So when one is encountered the RemoteSink
2613
 
        immediately stops using that verb and falls back to VFS insert_stream.
2614
 
        """
2615
 
        transport_path = 'quack'
2616
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2617
 
        client.add_expected_call(
2618
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2619
 
            'unknown', ('Repository.insert_stream_1.19',))
2620
 
        client.add_expected_call(
2621
 
            'Repository.insert_stream', ('quack/', ''),
2622
 
            'success', ('ok',))
2623
 
        client.add_expected_call(
2624
 
            'Repository.insert_stream', ('quack/', ''),
2625
 
            'success', ('ok',))
2626
 
        # Create a fake real repository for insert_stream to fall back on, so
2627
 
        # that we can directly see the records the RemoteSink passes to the
2628
 
        # real sink.
2629
 
        class FakeRealSink:
2630
 
            def __init__(self):
2631
 
                self.records = []
2632
 
            def insert_stream(self, stream, src_format, resume_tokens):
2633
 
                for substream_kind, substream in stream:
2634
 
                    self.records.append(
2635
 
                        (substream_kind, [record.key for record in substream]))
2636
 
                return ['fake tokens'], ['fake missing keys']
2637
 
        fake_real_sink = FakeRealSink()
2638
 
        class FakeRealRepository:
2639
 
            def _get_sink(self):
2640
 
                return fake_real_sink
2641
 
            def is_in_write_group(self):
2642
 
                return False
2643
 
            def refresh_data(self):
2644
 
                return True
2645
 
        repo._real_repository = FakeRealRepository()
2646
 
        sink = repo._get_sink()
2647
 
        fmt = repository.format_registry.get_default()
2648
 
        stream = self.make_stream_with_inv_deltas(fmt)
2649
 
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2650
 
        # Every record from the first inventory delta should have been sent to
2651
 
        # the VFS sink.
2652
 
        expected_records = [
2653
 
            ('inventory-deltas', [('rev2',), ('rev3',)]),
2654
 
            ('texts', [('some-rev', 'some-file')])]
2655
 
        self.assertEqual(expected_records, fake_real_sink.records)
2656
 
        # The return values from the real sink's insert_stream are propagated
2657
 
        # back to the original caller.
2658
 
        self.assertEqual(['fake tokens'], resume_tokens)
2659
 
        self.assertEqual(['fake missing keys'], missing_keys)
2660
 
        self.assertFinished(client)
2661
 
 
2662
 
    def make_stream_with_inv_deltas(self, fmt):
2663
 
        """Make a simple stream with an inventory delta followed by more
2664
 
        records and more substreams to test that all records and substreams
2665
 
        from that point on are used.
2666
 
 
2667
 
        This sends, in order:
2668
 
           * inventories substream: rev1, rev2, rev3.  rev2 and rev3 are
2669
 
             inventory-deltas.
2670
 
           * texts substream: (some-rev, some-file)
2671
 
        """
2672
 
        # Define a stream using generators so that it isn't rewindable.
2673
 
        inv = inventory.Inventory(revision_id='rev1')
2674
 
        inv.root.revision = 'rev1'
2675
 
        def stream_with_inv_delta():
2676
 
            yield ('inventories', inventories_substream())
2677
 
            yield ('inventory-deltas', inventory_delta_substream())
2678
 
            yield ('texts', [
2679
 
                versionedfile.FulltextContentFactory(
2680
 
                    ('some-rev', 'some-file'), (), None, 'content')])
2681
 
        def inventories_substream():
2682
 
            # An empty inventory fulltext.  This will be streamed normally.
2683
 
            text = fmt._serializer.write_inventory_to_string(inv)
2684
 
            yield versionedfile.FulltextContentFactory(
2685
 
                ('rev1',), (), None, text)
2686
 
        def inventory_delta_substream():
2687
 
            # An inventory delta.  This can't be streamed via this verb, so it
2688
 
            # will trigger a fallback to VFS insert_stream.
2689
 
            entry = inv.make_entry(
2690
 
                'directory', 'newdir', inv.root.file_id, 'newdir-id')
2691
 
            entry.revision = 'ghost'
2692
 
            delta = [(None, 'newdir', 'newdir-id', entry)]
2693
 
            serializer = inventory_delta.InventoryDeltaSerializer(
2694
 
                versioned_root=True, tree_references=False)
2695
 
            lines = serializer.delta_to_lines('rev1', 'rev2', delta)
2696
 
            yield versionedfile.ChunkedContentFactory(
2697
 
                ('rev2',), (('rev1',)), None, lines)
2698
 
            # Another delta.
2699
 
            lines = serializer.delta_to_lines('rev1', 'rev3', delta)
2700
 
            yield versionedfile.ChunkedContentFactory(
2701
 
                ('rev3',), (('rev1',)), None, lines)
2702
 
        return stream_with_inv_delta()
2703
 
 
2704
 
 
2705
 
class TestRepositoryInsertStream_1_19(TestRepositoryInsertStreamBase):
2706
 
 
2707
 
    def test_unlocked_repo(self):
2708
 
        transport_path = 'quack'
2709
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2710
 
        client.add_expected_call(
2711
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2712
 
            'success', ('ok',))
2713
 
        client.add_expected_call(
2714
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2715
 
            'success', ('ok',))
2716
 
        self.checkInsertEmptyStream(repo, client)
2717
 
 
2718
 
    def test_locked_repo_with_no_lock_token(self):
2719
 
        transport_path = 'quack'
2720
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2721
 
        client.add_expected_call(
2722
 
            'Repository.lock_write', ('quack/', ''),
2723
 
            'success', ('ok', ''))
2724
 
        client.add_expected_call(
2725
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2726
 
            'success', ('ok',))
2727
 
        client.add_expected_call(
2728
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2729
 
            'success', ('ok',))
2730
 
        repo.lock_write()
2731
 
        self.checkInsertEmptyStream(repo, client)
2732
 
 
2733
 
    def test_locked_repo_with_lock_token(self):
2734
 
        transport_path = 'quack'
2735
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2736
 
        client.add_expected_call(
2737
 
            'Repository.lock_write', ('quack/', ''),
2738
 
            'success', ('ok', 'a token'))
2739
 
        client.add_expected_call(
2740
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2741
 
            'success', ('ok',))
2742
 
        client.add_expected_call(
2743
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2744
 
            'success', ('ok',))
2745
 
        repo.lock_write()
2746
 
        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)
2747
2279
 
2748
2280
 
2749
2281
class TestRepositoryTarball(TestRemoteRepository):
2785
2317
    """RemoteRepository.copy_content_into optimizations"""
2786
2318
 
2787
2319
    def test_copy_content_remote_to_local(self):
2788
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2320
        self.transport_server = server.SmartTCPServer_for_testing
2789
2321
        src_repo = self.make_repository('repo1')
2790
2322
        src_repo = repository.Repository.open(self.get_url('repo1'))
2791
2323
        # At the moment the tarball-based copy_content_into can't write back
2870
2402
             ('pack collection autopack',)],
2871
2403
            client._calls)
2872
2404
 
2873
 
    def test_oom_error_reporting(self):
2874
 
        """An out-of-memory condition on the server is reported clearly"""
2875
 
        transport_path = 'quack'
2876
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2877
 
        client.add_expected_call(
2878
 
            'PackRepository.autopack', ('quack/',),
2879
 
            'error', ('MemoryError',))
2880
 
        err = self.assertRaises(errors.BzrError, repo.autopack)
2881
 
        self.assertContainsRe(str(err), "^remote server out of mem")
2882
 
 
2883
2405
 
2884
2406
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
2885
2407
    """Base class for unit tests for bzrlib.remote._translate_error."""
2949
2471
        expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
2950
2472
        self.assertEqual(expected_error, translated_error)
2951
2473
 
2952
 
    def test_nobranch_one_arg(self):
2953
 
        bzrdir = self.make_bzrdir('')
2954
 
        translated_error = self.translateTuple(
2955
 
            ('nobranch', 'extra detail'), bzrdir=bzrdir)
2956
 
        expected_error = errors.NotBranchError(
2957
 
            path=bzrdir.root_transport.base,
2958
 
            detail='extra detail')
2959
 
        self.assertEqual(expected_error, translated_error)
2960
 
 
2961
 
    def test_norepository(self):
2962
 
        bzrdir = self.make_bzrdir('')
2963
 
        translated_error = self.translateTuple(('norepository',),
2964
 
            bzrdir=bzrdir)
2965
 
        expected_error = errors.NoRepositoryPresent(bzrdir)
2966
 
        self.assertEqual(expected_error, translated_error)
2967
 
 
2968
2474
    def test_LockContention(self):
2969
2475
        translated_error = self.translateTuple(('LockContention',))
2970
2476
        expected_error = errors.LockContention('(remote lock)')
2998
2504
        expected_error = errors.DivergedBranches(branch, other_branch)
2999
2505
        self.assertEqual(expected_error, translated_error)
3000
2506
 
3001
 
    def test_NotStacked(self):
3002
 
        branch = self.make_branch('')
3003
 
        translated_error = self.translateTuple(('NotStacked',), branch=branch)
3004
 
        expected_error = errors.NotStacked(branch)
3005
 
        self.assertEqual(expected_error, translated_error)
3006
 
 
3007
2507
    def test_ReadError_no_args(self):
3008
2508
        path = 'a path'
3009
2509
        translated_error = self.translateTuple(('ReadError',), path=path)
3016
2516
        expected_error = errors.ReadError(path)
3017
2517
        self.assertEqual(expected_error, translated_error)
3018
2518
 
3019
 
    def test_IncompatibleRepositories(self):
3020
 
        translated_error = self.translateTuple(('IncompatibleRepositories',
3021
 
            "repo1", "repo2", "details here"))
3022
 
        expected_error = errors.IncompatibleRepositories("repo1", "repo2",
3023
 
            "details here")
3024
 
        self.assertEqual(expected_error, translated_error)
3025
 
 
3026
2519
    def test_PermissionDenied_no_args(self):
3027
2520
        path = 'a path'
3028
 
        translated_error = self.translateTuple(('PermissionDenied',),
3029
 
            path=path)
 
2521
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
3030
2522
        expected_error = errors.PermissionDenied(path)
3031
2523
        self.assertEqual(expected_error, translated_error)
3032
2524
 
3055
2547
        expected_error = errors.PermissionDenied(path, extra)
3056
2548
        self.assertEqual(expected_error, translated_error)
3057
2549
 
3058
 
    # GZ 2011-03-02: TODO test for PermissionDenied with non-ascii 'extra'
3059
 
 
3060
 
    def test_NoSuchFile_context_path(self):
3061
 
        local_path = "local path"
3062
 
        translated_error = self.translateTuple(('ReadError', "remote path"),
3063
 
            path=local_path)
3064
 
        expected_error = errors.ReadError(local_path)
3065
 
        self.assertEqual(expected_error, translated_error)
3066
 
 
3067
 
    def test_NoSuchFile_without_context(self):
3068
 
        remote_path = "remote path"
3069
 
        translated_error = self.translateTuple(('ReadError', remote_path))
3070
 
        expected_error = errors.ReadError(remote_path)
3071
 
        self.assertEqual(expected_error, translated_error)
3072
 
 
3073
 
    def test_ReadOnlyError(self):
3074
 
        translated_error = self.translateTuple(('ReadOnlyError',))
3075
 
        expected_error = errors.TransportNotPossible("readonly transport")
3076
 
        self.assertEqual(expected_error, translated_error)
3077
 
 
3078
 
    def test_MemoryError(self):
3079
 
        translated_error = self.translateTuple(('MemoryError',))
3080
 
        self.assertStartsWith(str(translated_error),
3081
 
            "remote server out of memory")
3082
 
 
3083
 
    def test_generic_IndexError_no_classname(self):
3084
 
        err = errors.ErrorFromSmartServer(('error', "list index out of range"))
3085
 
        translated_error = self.translateErrorFromSmartServer(err)
3086
 
        expected_error = errors.UnknownErrorFromSmartServer(err)
3087
 
        self.assertEqual(expected_error, translated_error)
3088
 
 
3089
 
    # GZ 2011-03-02: TODO test generic non-ascii error string
3090
 
 
3091
 
    def test_generic_KeyError(self):
3092
 
        err = errors.ErrorFromSmartServer(('error', 'KeyError', "1"))
3093
 
        translated_error = self.translateErrorFromSmartServer(err)
3094
 
        expected_error = errors.UnknownErrorFromSmartServer(err)
3095
 
        self.assertEqual(expected_error, translated_error)
3096
 
 
3097
2550
 
3098
2551
class TestErrorTranslationRobustness(TestErrorTranslationBase):
3099
2552
    """Unit tests for bzrlib.remote._translate_error's robustness.
3129
2582
        # In addition to re-raising ErrorFromSmartServer, some debug info has
3130
2583
        # been muttered to the log file for developer to look at.
3131
2584
        self.assertContainsRe(
3132
 
            self.get_log(),
 
2585
            self._get_log(keep_log_file=True),
3133
2586
            "Missing key 'branch' in context")
3134
2587
 
3135
2588
    def test_path_missing(self):
3143
2596
        self.assertEqual(server_error, translated_error)
3144
2597
        # In addition to re-raising ErrorFromSmartServer, some debug info has
3145
2598
        # been muttered to the log file for developer to look at.
3146
 
        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")
3147
2601
 
3148
2602
 
3149
2603
class TestStacking(tests.TestCaseWithTransport):
3167
2621
        stacked_branch = self.make_branch('stacked', format='1.9')
3168
2622
        stacked_branch.set_stacked_on_url('../base')
3169
2623
        # start a server looking at this
3170
 
        smart_server = test_server.SmartTCPServer_for_testing()
3171
 
        self.start_server(smart_server)
 
2624
        smart_server = server.SmartTCPServer_for_testing()
 
2625
        smart_server.setUp()
 
2626
        self.addCleanup(smart_server.tearDown)
3172
2627
        remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
3173
2628
        # can get its branch and repository
3174
2629
        remote_branch = remote_bzrdir.open_branch()
3196
2651
        tree1.commit('rev1', rev_id='rev1')
3197
2652
        tree2 = tree1.branch.bzrdir.sprout('tree2', stacked=True
3198
2653
            ).open_workingtree()
3199
 
        local_tree = tree2.branch.create_checkout('local')
3200
 
        local_tree.commit('local changes make me feel good.')
 
2654
        tree2.commit('local changes make me feel good.')
3201
2655
        branch2 = Branch.open(self.get_url('tree2'))
3202
2656
        branch2.lock_read()
3203
2657
        self.addCleanup(branch2.unlock)
3244
2698
        _, stacked = branch_factory()
3245
2699
        source = stacked.repository._get_source(target_repository_format)
3246
2700
        tip = stacked.last_revision()
3247
 
        stacked.repository._ensure_real()
3248
 
        graph = stacked.repository.get_graph()
3249
 
        revs = [r for (r,ps) in graph.iter_ancestry([tip])
3250
 
                if r != NULL_REVISION]
3251
 
        revs.reverse()
3252
 
        search = _mod_graph.PendingAncestryResult([tip], stacked.repository)
 
2701
        revs = stacked.repository.get_ancestry(tip)
 
2702
        search = graph.PendingAncestryResult([tip], stacked.repository)
3253
2703
        self.reset_smart_call_log()
3254
2704
        stream = source.get_stream(search)
 
2705
        if None in revs:
 
2706
            revs.remove(None)
3255
2707
        # We trust that if a revision is in the stream the rest of the new
3256
2708
        # content for it is too, as per our main fetch tests; here we are
3257
2709
        # checking that the revisions are actually included at all, and their
3275
2727
            _, stacked = self.prepare_stacked_remote_branch()
3276
2728
            tree = stacked.bzrdir.sprout('tree3', stacked=True
3277
2729
                ).open_workingtree()
3278
 
            local_tree = tree.branch.create_checkout('local-tree3')
3279
 
            local_tree.commit('more local changes are better')
 
2730
            tree.commit('more local changes are better')
3280
2731
            branch = Branch.open(self.get_url('tree3'))
3281
2732
            branch.lock_read()
3282
 
            self.addCleanup(branch.unlock)
3283
2733
            return None, branch
3284
2734
        rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
3285
2735
            branch_factory=make_stacked_stacked)
3294
2744
        # stacked upon sources in topological order.
3295
2745
        rev_ord, expected_revs = self.get_ordered_revs('knit', 'topological')
3296
2746
        self.assertEqual(expected_revs, rev_ord)
3297
 
        # Getting topological sort requires VFS calls still - one of which is
3298
 
        # pushing up from the bound branch.
3299
 
        self.assertLength(14, self.hpss_calls)
 
2747
        # Getting topological sort requires VFS calls still
 
2748
        self.assertLength(12, self.hpss_calls)
3300
2749
 
3301
2750
    def test_stacked_get_stream_groupcompress(self):
3302
2751
        # Repository._get_source.get_stream() from a stacked repository with
3331
2780
        super(TestRemoteBranchEffort, self).setUp()
3332
2781
        # Create a smart server that publishes whatever the backing VFS server
3333
2782
        # does.
3334
 
        self.smart_server = test_server.SmartTCPServer_for_testing()
3335
 
        self.start_server(self.smart_server, self.get_server())
 
2783
        self.smart_server = server.SmartTCPServer_for_testing()
 
2784
        self.smart_server.setUp(self.get_server())
 
2785
        self.addCleanup(self.smart_server.tearDown)
3336
2786
        # Log all HPSS calls into self.hpss_calls.
3337
2787
        _SmartClient.hooks.install_named_hook(
3338
2788
            'call', self.capture_hpss_call, None)
3343
2793
 
3344
2794
    def test_copy_content_into_avoids_revision_history(self):
3345
2795
        local = self.make_branch('local')
3346
 
        builder = self.make_branch_builder('remote')
3347
 
        builder.build_commit(message="Commit.")
 
2796
        remote_backing_tree = self.make_branch_and_tree('remote')
 
2797
        remote_backing_tree.commit("Commit.")
3348
2798
        remote_branch_url = self.smart_server.get_url() + 'remote'
3349
2799
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3350
2800
        local.repository.fetch(remote_branch.repository)
3351
2801
        self.hpss_calls = []
3352
2802
        remote_branch.copy_content_into(local)
3353
2803
        self.assertFalse('Branch.revision_history' in self.hpss_calls)
3354
 
 
3355
 
    def test_fetch_everything_needs_just_one_call(self):
3356
 
        local = self.make_branch('local')
3357
 
        builder = self.make_branch_builder('remote')
3358
 
        builder.build_commit(message="Commit.")
3359
 
        remote_branch_url = self.smart_server.get_url() + 'remote'
3360
 
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3361
 
        self.hpss_calls = []
3362
 
        local.repository.fetch(remote_branch.repository,
3363
 
                fetch_spec=_mod_graph.EverythingResult(remote_branch.repository))
3364
 
        self.assertEqual(['Repository.get_stream_1.19'], self.hpss_calls)
3365
 
 
3366
 
    def override_verb(self, verb_name, verb):
3367
 
        request_handlers = request.request_handlers
3368
 
        orig_verb = request_handlers.get(verb_name)
3369
 
        request_handlers.register(verb_name, verb, override_existing=True)
3370
 
        self.addCleanup(request_handlers.register, verb_name, orig_verb,
3371
 
                override_existing=True)
3372
 
 
3373
 
    def test_fetch_everything_backwards_compat(self):
3374
 
        """Can fetch with EverythingResult even with pre 2.4 servers.
3375
 
        
3376
 
        Pre-2.4 do not support 'everything' searches with the
3377
 
        Repository.get_stream_1.19 verb.
3378
 
        """
3379
 
        verb_log = []
3380
 
        class OldGetStreamVerb(SmartServerRepositoryGetStream_1_19):
3381
 
            """A version of the Repository.get_stream_1.19 verb patched to
3382
 
            reject 'everything' searches the way 2.3 and earlier do.
3383
 
            """
3384
 
            def recreate_search(self, repository, search_bytes, discard_excess=False):
3385
 
                verb_log.append(search_bytes.split('\n', 1)[0])
3386
 
                if search_bytes == 'everything':
3387
 
                    return (None, request.FailedSmartServerResponse(('BadSearch',)))
3388
 
                return super(OldGetStreamVerb,
3389
 
                        self).recreate_search(repository, search_bytes,
3390
 
                            discard_excess=discard_excess)
3391
 
        self.override_verb('Repository.get_stream_1.19', OldGetStreamVerb)
3392
 
        local = self.make_branch('local')
3393
 
        builder = self.make_branch_builder('remote')
3394
 
        builder.build_commit(message="Commit.")
3395
 
        remote_branch_url = self.smart_server.get_url() + 'remote'
3396
 
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3397
 
        self.hpss_calls = []
3398
 
        local.repository.fetch(remote_branch.repository,
3399
 
                fetch_spec=_mod_graph.EverythingResult(remote_branch.repository))
3400
 
        # make sure the overridden verb was used
3401
 
        self.assertLength(1, verb_log)
3402
 
        # more than one HPSS call is needed, but because it's a VFS callback
3403
 
        # its hard to predict exactly how many.
3404
 
        self.assertTrue(len(self.hpss_calls) > 1)
3405