/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_remote.py

  • Committer: Martin von Gagern
  • Date: 2010-04-20 08:47:38 UTC
  • mfrom: (5167 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5195.
  • Revision ID: martin.vgagern@gmx.net-20100420084738-ygymnqmdllzrhpfn
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for remote bzrdir/branch/repo/etc
18
18
 
19
19
These are proxy objects which act on remote objects by sending messages
20
20
through a smart client.  The proxies are to be created when attempting to open
21
 
the object given a transport that supports smartserver rpc operations. 
 
21
the object given a transport that supports smartserver rpc operations.
22
22
 
23
23
These tests correspond to tests.test_smart, which exercises the server side.
24
24
"""
27
27
from cStringIO import StringIO
28
28
 
29
29
from bzrlib import (
 
30
    branch,
 
31
    bzrdir,
 
32
    config,
30
33
    errors,
31
34
    graph,
 
35
    inventory,
 
36
    inventory_delta,
32
37
    pack,
33
38
    remote,
34
39
    repository,
35
40
    tests,
 
41
    treebuilder,
36
42
    urlutils,
 
43
    versionedfile,
37
44
    )
38
45
from bzrlib.branch import Branch
39
46
from bzrlib.bzrdir import BzrDir, BzrDirFormat
40
47
from bzrlib.remote import (
41
48
    RemoteBranch,
 
49
    RemoteBranchFormat,
42
50
    RemoteBzrDir,
43
51
    RemoteBzrDirFormat,
44
52
    RemoteRepository,
 
53
    RemoteRepositoryFormat,
45
54
    )
 
55
from bzrlib.repofmt import groupcompress_repo, pack_repo
46
56
from bzrlib.revision import NULL_REVISION
47
 
from bzrlib.smart import server, medium
 
57
from bzrlib.smart import medium
48
58
from bzrlib.smart.client import _SmartClient
49
 
from bzrlib.symbol_versioning import one_four
50
 
from bzrlib.transport import get_transport, http
 
59
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
 
60
from bzrlib.tests import (
 
61
    condition_isinstance,
 
62
    split_suite_by_condition,
 
63
    multiply_tests,
 
64
    test_server,
 
65
    )
 
66
from bzrlib.transport import get_transport
51
67
from bzrlib.transport.memory import MemoryTransport
52
 
from bzrlib.transport.remote import RemoteTransport, RemoteTCPTransport
 
68
from bzrlib.transport.remote import (
 
69
    RemoteTransport,
 
70
    RemoteSSHTransport,
 
71
    RemoteTCPTransport,
 
72
)
 
73
 
 
74
def load_tests(standard_tests, module, loader):
 
75
    to_adapt, result = split_suite_by_condition(
 
76
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
 
77
    smart_server_version_scenarios = [
 
78
        ('HPSS-v2',
 
79
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
 
80
        ('HPSS-v3',
 
81
         {'transport_server': test_server.SmartTCPServer_for_testing})]
 
82
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
53
83
 
54
84
 
55
85
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
56
86
 
57
87
    def setUp(self):
58
 
        self.transport_server = server.SmartTCPServer_for_testing
59
88
        super(BasicRemoteObjectTests, self).setUp()
60
89
        self.transport = self.get_transport()
61
90
        # make a branch that can be opened over the smart transport
66
95
        tests.TestCaseWithTransport.tearDown(self)
67
96
 
68
97
    def test_create_remote_bzrdir(self):
69
 
        b = remote.RemoteBzrDir(self.transport)
 
98
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
70
99
        self.assertIsInstance(b, BzrDir)
71
100
 
72
101
    def test_open_remote_branch(self):
73
102
        # open a standalone branch in the working directory
74
 
        b = remote.RemoteBzrDir(self.transport)
 
103
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
75
104
        branch = b.open_branch()
76
105
        self.assertIsInstance(branch, Branch)
77
106
 
106
135
        b = BzrDir.open_from_transport(self.transport).open_branch()
107
136
        self.assertStartsWith(str(b), 'RemoteBranch(')
108
137
 
109
 
 
110
 
class FakeRemoteTransport(object):
111
 
    """This class provides the minimum support for use in place of a RemoteTransport.
112
 
    
113
 
    It doesn't actually transmit requests, but rather expects them to be
114
 
    handled by a FakeClient which holds canned responses.  It does not allow
115
 
    any vfs access, therefore is not suitable for testing any operation that
116
 
    will fallback to vfs access.  Backing the test by an instance of this
117
 
    class guarantees that it's - done using non-vfs operations.
118
 
    """
119
 
 
120
 
    _default_url = 'fakeremotetransport://host/path/'
121
 
 
122
 
    def __init__(self, url=None):
123
 
        if url is None:
124
 
            url = self._default_url
125
 
        self.base = url
126
 
 
127
 
    def __repr__(self):
128
 
        return "%r(%r)" % (self.__class__.__name__,
129
 
            self.base)
130
 
 
131
 
    def clone(self, relpath):
132
 
        return FakeRemoteTransport(urlutils.join(self.base, relpath))
133
 
 
134
 
    def get(self, relpath):
135
 
        # only get is specifically stubbed out, because it's usually the first
136
 
        # thing we do.  anything else will fail with an AttributeError.
137
 
        raise AssertionError("%r doesn't support file access to %r"
138
 
            % (self, relpath))
139
 
 
 
138
    def test_remote_bzrdir_repr(self):
 
139
        b = BzrDir.open_from_transport(self.transport)
 
140
        self.assertStartsWith(str(b), 'RemoteBzrDir(')
 
141
 
 
142
    def test_remote_branch_format_supports_stacking(self):
 
143
        t = self.transport
 
144
        self.make_branch('unstackable', format='pack-0.92')
 
145
        b = BzrDir.open_from_transport(t.clone('unstackable')).open_branch()
 
146
        self.assertFalse(b._format.supports_stacking())
 
147
        self.make_branch('stackable', format='1.9')
 
148
        b = BzrDir.open_from_transport(t.clone('stackable')).open_branch()
 
149
        self.assertTrue(b._format.supports_stacking())
 
150
 
 
151
    def test_remote_repo_format_supports_external_references(self):
 
152
        t = self.transport
 
153
        bd = self.make_bzrdir('unstackable', format='pack-0.92')
 
154
        r = bd.create_repository()
 
155
        self.assertFalse(r._format.supports_external_lookups)
 
156
        r = BzrDir.open_from_transport(t.clone('unstackable')).open_repository()
 
157
        self.assertFalse(r._format.supports_external_lookups)
 
158
        bd = self.make_bzrdir('stackable', format='1.9')
 
159
        r = bd.create_repository()
 
160
        self.assertTrue(r._format.supports_external_lookups)
 
161
        r = BzrDir.open_from_transport(t.clone('stackable')).open_repository()
 
162
        self.assertTrue(r._format.supports_external_lookups)
 
163
 
 
164
    def test_remote_branch_set_append_revisions_only(self):
 
165
        # Make a format 1.9 branch, which supports append_revisions_only
 
166
        branch = self.make_branch('branch', format='1.9')
 
167
        config = branch.get_config()
 
168
        branch.set_append_revisions_only(True)
 
169
        self.assertEqual(
 
170
            'True', config.get_user_option('append_revisions_only'))
 
171
        branch.set_append_revisions_only(False)
 
172
        self.assertEqual(
 
173
            'False', config.get_user_option('append_revisions_only'))
 
174
 
 
175
    def test_remote_branch_set_append_revisions_only_upgrade_reqd(self):
 
176
        branch = self.make_branch('branch', format='knit')
 
177
        config = branch.get_config()
 
178
        self.assertRaises(
 
179
            errors.UpgradeRequired, branch.set_append_revisions_only, True)
140
180
 
141
181
 
142
182
class FakeProtocol(object):
164
204
 
165
205
class FakeClient(_SmartClient):
166
206
    """Lookalike for _SmartClient allowing testing."""
167
 
    
 
207
 
168
208
    def __init__(self, fake_medium_base='fake base'):
169
 
        """Create a FakeClient.
170
 
 
171
 
        :param responses: A list of response-tuple, body-data pairs to be sent
172
 
            back to callers.  A special case is if the response-tuple is
173
 
            'unknown verb', then a UnknownSmartMethod will be raised for that
174
 
            call, using the second element of the tuple as the verb in the
175
 
            exception.
176
 
        """
 
209
        """Create a FakeClient."""
177
210
        self.responses = []
178
211
        self._calls = []
179
212
        self.expecting_body = False
180
213
        # if non-None, this is the list of expected calls, with only the
181
214
        # method name and arguments included.  the body might be hard to
182
 
        # compute so is not included
 
215
        # compute so is not included. If a call is None, that call can
 
216
        # be anything.
183
217
        self._expected_calls = None
184
218
        _SmartClient.__init__(self, FakeMedium(self._calls, fake_medium_base))
185
219
 
195
229
 
196
230
    def add_success_response_with_body(self, body, *args):
197
231
        self.responses.append(('success', args, body))
 
232
        if self._expected_calls is not None:
 
233
            self._expected_calls.append(None)
198
234
 
199
235
    def add_error_response(self, *args):
200
236
        self.responses.append(('error', args))
229
265
            raise AssertionError("%r didn't expect any more calls "
230
266
                "but got %r%r"
231
267
                % (self, method, args,))
 
268
        if next_call is None:
 
269
            return
232
270
        if method != next_call[0] or args != next_call[1]:
233
271
            raise AssertionError("%r expected %r%r "
234
272
                "but got %r%r"
246
284
        self.expecting_body = True
247
285
        return result[1], FakeProtocol(result[2], self)
248
286
 
 
287
    def call_with_body_bytes(self, method, args, body):
 
288
        self._check_call(method, args)
 
289
        self._calls.append(('call_with_body_bytes', method, args, body))
 
290
        result = self._get_next_response()
 
291
        return result[1], FakeProtocol(result[2], self)
 
292
 
249
293
    def call_with_body_bytes_expecting_body(self, method, args, body):
250
294
        self._check_call(method, args)
251
295
        self._calls.append(('call_with_body_bytes_expecting_body', method,
254
298
        self.expecting_body = True
255
299
        return result[1], FakeProtocol(result[2], self)
256
300
 
 
301
    def call_with_body_stream(self, args, stream):
 
302
        # Explicitly consume the stream before checking for an error, because
 
303
        # that's what happens a real medium.
 
304
        stream = list(stream)
 
305
        self._check_call(args[0], args[1:])
 
306
        self._calls.append(('call_with_body_stream', args[0], args[1:], stream))
 
307
        result = self._get_next_response()
 
308
        # The second value returned from call_with_body_stream is supposed to
 
309
        # be a response_handler object, but so far no tests depend on that.
 
310
        response_handler = None 
 
311
        return result[1], response_handler
 
312
 
257
313
 
258
314
class FakeMedium(medium.SmartClientMedium):
259
315
 
279
335
        self.assertTrue(result)
280
336
 
281
337
 
 
338
class TestRemote(tests.TestCaseWithMemoryTransport):
 
339
 
 
340
    def get_branch_format(self):
 
341
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
342
        return reference_bzrdir_format.get_branch_format()
 
343
 
 
344
    def get_repo_format(self):
 
345
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
346
        return reference_bzrdir_format.repository_format
 
347
 
 
348
    def assertFinished(self, fake_client):
 
349
        """Assert that all of a FakeClient's expected calls have occurred."""
 
350
        fake_client.finished_test()
 
351
 
 
352
 
282
353
class Test_ClientMedium_remote_path_from_transport(tests.TestCase):
283
354
    """Tests for the behaviour of client_medium.remote_path_from_transport."""
284
355
 
311
382
        cloned_transport = base_transport.clone(relpath)
312
383
        result = client_medium.remote_path_from_transport(cloned_transport)
313
384
        self.assertEqual(expected, result)
314
 
        
 
385
 
315
386
    def test_remote_path_from_transport_http(self):
316
387
        """Remote paths for HTTP transports are calculated differently to other
317
388
        transports.  They are just relative to the client base, not the root
333
404
        """
334
405
        client_medium = medium.SmartClientMedium('dummy base')
335
406
        self.assertFalse(client_medium._is_remote_before((99, 99)))
336
 
    
 
407
 
337
408
    def test__remember_remote_is_before(self):
338
409
        """Calling _remember_remote_is_before ratchets down the known remote
339
410
        version.
352
423
            AssertionError, client_medium._remember_remote_is_before, (1, 9))
353
424
 
354
425
 
355
 
class TestBzrDirOpenBranch(tests.TestCase):
 
426
class TestBzrDirCloningMetaDir(TestRemote):
 
427
 
 
428
    def test_backwards_compat(self):
 
429
        self.setup_smart_server_with_call_log()
 
430
        a_dir = self.make_bzrdir('.')
 
431
        self.reset_smart_call_log()
 
432
        verb = 'BzrDir.cloning_metadir'
 
433
        self.disable_verb(verb)
 
434
        format = a_dir.cloning_metadir()
 
435
        call_count = len([call for call in self.hpss_calls if
 
436
            call.call.method == verb])
 
437
        self.assertEqual(1, call_count)
 
438
 
 
439
    def test_branch_reference(self):
 
440
        transport = self.get_transport('quack')
 
441
        referenced = self.make_branch('referenced')
 
442
        expected = referenced.bzrdir.cloning_metadir()
 
443
        client = FakeClient(transport.base)
 
444
        client.add_expected_call(
 
445
            'BzrDir.cloning_metadir', ('quack/', 'False'),
 
446
            'error', ('BranchReference',)),
 
447
        client.add_expected_call(
 
448
            'BzrDir.open_branchV3', ('quack/',),
 
449
            'success', ('ref', self.get_url('referenced'))),
 
450
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
451
            _client=client)
 
452
        result = a_bzrdir.cloning_metadir()
 
453
        # We should have got a control dir matching the referenced branch.
 
454
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
 
455
        self.assertEqual(expected._repository_format, result._repository_format)
 
456
        self.assertEqual(expected._branch_format, result._branch_format)
 
457
        self.assertFinished(client)
 
458
 
 
459
    def test_current_server(self):
 
460
        transport = self.get_transport('.')
 
461
        transport = transport.clone('quack')
 
462
        self.make_bzrdir('quack')
 
463
        client = FakeClient(transport.base)
 
464
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
465
        control_name = reference_bzrdir_format.network_name()
 
466
        client.add_expected_call(
 
467
            'BzrDir.cloning_metadir', ('quack/', 'False'),
 
468
            'success', (control_name, '', ('branch', ''))),
 
469
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
470
            _client=client)
 
471
        result = a_bzrdir.cloning_metadir()
 
472
        # We should have got a reference control dir with default branch and
 
473
        # repository formats.
 
474
        # This pokes a little, just to be sure.
 
475
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
 
476
        self.assertEqual(None, result._repository_format)
 
477
        self.assertEqual(None, result._branch_format)
 
478
        self.assertFinished(client)
 
479
 
 
480
 
 
481
class TestBzrDirOpen(TestRemote):
 
482
 
 
483
    def make_fake_client_and_transport(self, path='quack'):
 
484
        transport = MemoryTransport()
 
485
        transport.mkdir(path)
 
486
        transport = transport.clone(path)
 
487
        client = FakeClient(transport.base)
 
488
        return client, transport
 
489
 
 
490
    def test_absent(self):
 
491
        client, transport = self.make_fake_client_and_transport()
 
492
        client.add_expected_call(
 
493
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
 
494
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
 
495
                remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
 
496
        self.assertFinished(client)
 
497
 
 
498
    def test_present_without_workingtree(self):
 
499
        client, transport = self.make_fake_client_and_transport()
 
500
        client.add_expected_call(
 
501
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
 
502
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
503
            _client=client, _force_probe=True)
 
504
        self.assertIsInstance(bd, RemoteBzrDir)
 
505
        self.assertFalse(bd.has_workingtree())
 
506
        self.assertRaises(errors.NoWorkingTree, bd.open_workingtree)
 
507
        self.assertFinished(client)
 
508
 
 
509
    def test_present_with_workingtree(self):
 
510
        client, transport = self.make_fake_client_and_transport()
 
511
        client.add_expected_call(
 
512
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
 
513
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
514
            _client=client, _force_probe=True)
 
515
        self.assertIsInstance(bd, RemoteBzrDir)
 
516
        self.assertTrue(bd.has_workingtree())
 
517
        self.assertRaises(errors.NotLocalUrl, bd.open_workingtree)
 
518
        self.assertFinished(client)
 
519
 
 
520
    def test_backwards_compat(self):
 
521
        client, transport = self.make_fake_client_and_transport()
 
522
        client.add_expected_call(
 
523
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
 
524
        client.add_expected_call(
 
525
            'BzrDir.open', ('quack/',), 'success', ('yes',))
 
526
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
527
            _client=client, _force_probe=True)
 
528
        self.assertIsInstance(bd, RemoteBzrDir)
 
529
        self.assertFinished(client)
 
530
 
 
531
 
 
532
class TestBzrDirOpenBranch(TestRemote):
 
533
 
 
534
    def test_backwards_compat(self):
 
535
        self.setup_smart_server_with_call_log()
 
536
        self.make_branch('.')
 
537
        a_dir = BzrDir.open(self.get_url('.'))
 
538
        self.reset_smart_call_log()
 
539
        verb = 'BzrDir.open_branchV3'
 
540
        self.disable_verb(verb)
 
541
        format = a_dir.open_branch()
 
542
        call_count = len([call for call in self.hpss_calls if
 
543
            call.call.method == verb])
 
544
        self.assertEqual(1, call_count)
356
545
 
357
546
    def test_branch_present(self):
 
547
        reference_format = self.get_repo_format()
 
548
        network_name = reference_format.network_name()
 
549
        branch_network_name = self.get_branch_format().network_name()
358
550
        transport = MemoryTransport()
359
551
        transport.mkdir('quack')
360
552
        transport = transport.clone('quack')
361
553
        client = FakeClient(transport.base)
362
554
        client.add_expected_call(
363
 
            'BzrDir.open_branch', ('quack/',),
364
 
            'success', ('ok', ''))
 
555
            'BzrDir.open_branchV3', ('quack/',),
 
556
            'success', ('branch', branch_network_name))
365
557
        client.add_expected_call(
366
 
            'BzrDir.find_repositoryV2', ('quack/',),
367
 
            'success', ('ok', '', 'no', 'no', 'no'))
 
558
            'BzrDir.find_repositoryV3', ('quack/',),
 
559
            'success', ('ok', '', 'no', 'no', 'no', network_name))
368
560
        client.add_expected_call(
369
561
            'Branch.get_stacked_on_url', ('quack/',),
370
562
            'error', ('NotStacked',))
371
 
        bzrdir = RemoteBzrDir(transport, _client=client)
 
563
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
564
            _client=client)
372
565
        result = bzrdir.open_branch()
373
566
        self.assertIsInstance(result, RemoteBranch)
374
567
        self.assertEqual(bzrdir, result.bzrdir)
375
 
        client.finished_test()
 
568
        self.assertFinished(client)
376
569
 
377
570
    def test_branch_missing(self):
378
571
        transport = MemoryTransport()
380
573
        transport = transport.clone('quack')
381
574
        client = FakeClient(transport.base)
382
575
        client.add_error_response('nobranch')
383
 
        bzrdir = RemoteBzrDir(transport, _client=client)
 
576
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
577
            _client=client)
384
578
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
385
579
        self.assertEqual(
386
 
            [('call', 'BzrDir.open_branch', ('quack/',))],
 
580
            [('call', 'BzrDir.open_branchV3', ('quack/',))],
387
581
            client._calls)
388
582
 
389
583
    def test__get_tree_branch(self):
396
590
        transport = MemoryTransport()
397
591
        # no requests on the network - catches other api calls being made.
398
592
        client = FakeClient(transport.base)
399
 
        bzrdir = RemoteBzrDir(transport, _client=client)
 
593
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
594
            _client=client)
400
595
        # patch the open_branch call to record that it was called.
401
596
        bzrdir.open_branch = open_branch
402
597
        self.assertEqual((None, "a-branch"), bzrdir._get_tree_branch())
408
603
        # transmitted as "~", not "%7E".
409
604
        transport = RemoteTCPTransport('bzr://localhost/~hello/')
410
605
        client = FakeClient(transport.base)
411
 
        client.add_expected_call(
412
 
            'BzrDir.open_branch', ('~hello/',),
413
 
            'success', ('ok', ''))
414
 
        client.add_expected_call(
415
 
            'BzrDir.find_repositoryV2', ('~hello/',),
416
 
            'success', ('ok', '', 'no', 'no', 'no'))
 
606
        reference_format = self.get_repo_format()
 
607
        network_name = reference_format.network_name()
 
608
        branch_network_name = self.get_branch_format().network_name()
 
609
        client.add_expected_call(
 
610
            'BzrDir.open_branchV3', ('~hello/',),
 
611
            'success', ('branch', branch_network_name))
 
612
        client.add_expected_call(
 
613
            'BzrDir.find_repositoryV3', ('~hello/',),
 
614
            'success', ('ok', '', 'no', 'no', 'no', network_name))
417
615
        client.add_expected_call(
418
616
            'Branch.get_stacked_on_url', ('~hello/',),
419
617
            'error', ('NotStacked',))
420
 
        bzrdir = RemoteBzrDir(transport, _client=client)
 
618
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
619
            _client=client)
421
620
        result = bzrdir.open_branch()
422
 
        client.finished_test()
 
621
        self.assertFinished(client)
423
622
 
424
623
    def check_open_repository(self, rich_root, subtrees, external_lookup='no'):
 
624
        reference_format = self.get_repo_format()
 
625
        network_name = reference_format.network_name()
425
626
        transport = MemoryTransport()
426
627
        transport.mkdir('quack')
427
628
        transport = transport.clone('quack')
435
636
            subtree_response = 'no'
436
637
        client = FakeClient(transport.base)
437
638
        client.add_success_response(
438
 
            'ok', '', rich_response, subtree_response, external_lookup)
439
 
        bzrdir = RemoteBzrDir(transport, _client=client)
 
639
            'ok', '', rich_response, subtree_response, external_lookup,
 
640
            network_name)
 
641
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
642
            _client=client)
440
643
        result = bzrdir.open_repository()
441
644
        self.assertEqual(
442
 
            [('call', 'BzrDir.find_repositoryV2', ('quack/',))],
 
645
            [('call', 'BzrDir.find_repositoryV3', ('quack/',))],
443
646
            client._calls)
444
647
        self.assertIsInstance(result, RemoteRepository)
445
648
        self.assertEqual(bzrdir, result.bzrdir)
461
664
            RemoteBzrDirFormat.probe_transport, OldServerTransport())
462
665
 
463
666
 
464
 
class TestBzrDirOpenRepository(tests.TestCase):
465
 
 
466
 
    def test_backwards_compat_1_2(self):
467
 
        transport = MemoryTransport()
468
 
        transport.mkdir('quack')
469
 
        transport = transport.clone('quack')
470
 
        client = FakeClient(transport.base)
471
 
        client.add_unknown_method_response('RemoteRepository.find_repositoryV2')
 
667
class TestBzrDirCreateBranch(TestRemote):
 
668
 
 
669
    def test_backwards_compat(self):
 
670
        self.setup_smart_server_with_call_log()
 
671
        repo = self.make_repository('.')
 
672
        self.reset_smart_call_log()
 
673
        self.disable_verb('BzrDir.create_branch')
 
674
        branch = repo.bzrdir.create_branch()
 
675
        create_branch_call_count = len([call for call in self.hpss_calls if
 
676
            call.call.method == 'BzrDir.create_branch'])
 
677
        self.assertEqual(1, create_branch_call_count)
 
678
 
 
679
    def test_current_server(self):
 
680
        transport = self.get_transport('.')
 
681
        transport = transport.clone('quack')
 
682
        self.make_repository('quack')
 
683
        client = FakeClient(transport.base)
 
684
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
685
        reference_format = reference_bzrdir_format.get_branch_format()
 
686
        network_name = reference_format.network_name()
 
687
        reference_repo_fmt = reference_bzrdir_format.repository_format
 
688
        reference_repo_name = reference_repo_fmt.network_name()
 
689
        client.add_expected_call(
 
690
            'BzrDir.create_branch', ('quack/', network_name),
 
691
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
 
692
            reference_repo_name))
 
693
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
694
            _client=client)
 
695
        branch = a_bzrdir.create_branch()
 
696
        # We should have got a remote branch
 
697
        self.assertIsInstance(branch, remote.RemoteBranch)
 
698
        # its format should have the settings from the response
 
699
        format = branch._format
 
700
        self.assertEqual(network_name, format.network_name())
 
701
 
 
702
 
 
703
class TestBzrDirCreateRepository(TestRemote):
 
704
 
 
705
    def test_backwards_compat(self):
 
706
        self.setup_smart_server_with_call_log()
 
707
        bzrdir = self.make_bzrdir('.')
 
708
        self.reset_smart_call_log()
 
709
        self.disable_verb('BzrDir.create_repository')
 
710
        repo = bzrdir.create_repository()
 
711
        create_repo_call_count = len([call for call in self.hpss_calls if
 
712
            call.call.method == 'BzrDir.create_repository'])
 
713
        self.assertEqual(1, create_repo_call_count)
 
714
 
 
715
    def test_current_server(self):
 
716
        transport = self.get_transport('.')
 
717
        transport = transport.clone('quack')
 
718
        self.make_bzrdir('quack')
 
719
        client = FakeClient(transport.base)
 
720
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
721
        reference_format = reference_bzrdir_format.repository_format
 
722
        network_name = reference_format.network_name()
 
723
        client.add_expected_call(
 
724
            'BzrDir.create_repository', ('quack/',
 
725
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
 
726
                'False'),
 
727
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
 
728
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
729
            _client=client)
 
730
        repo = a_bzrdir.create_repository()
 
731
        # We should have got a remote repository
 
732
        self.assertIsInstance(repo, remote.RemoteRepository)
 
733
        # its format should have the settings from the response
 
734
        format = repo._format
 
735
        self.assertTrue(format.rich_root_data)
 
736
        self.assertTrue(format.supports_tree_reference)
 
737
        self.assertTrue(format.supports_external_lookups)
 
738
        self.assertEqual(network_name, format.network_name())
 
739
 
 
740
 
 
741
class TestBzrDirOpenRepository(TestRemote):
 
742
 
 
743
    def test_backwards_compat_1_2_3(self):
 
744
        # fallback all the way to the first version.
 
745
        reference_format = self.get_repo_format()
 
746
        network_name = reference_format.network_name()
 
747
        server_url = 'bzr://example.com/'
 
748
        self.permit_url(server_url)
 
749
        client = FakeClient(server_url)
 
750
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
 
751
        client.add_unknown_method_response('BzrDir.find_repositoryV2')
472
752
        client.add_success_response('ok', '', 'no', 'no')
473
 
        bzrdir = RemoteBzrDir(transport, _client=client)
474
 
        repo = bzrdir.open_repository()
475
 
        self.assertEqual(
476
 
            [('call', 'BzrDir.find_repositoryV2', ('quack/',)),
477
 
             ('call', 'BzrDir.find_repository', ('quack/',))],
478
 
            client._calls)
 
753
        # A real repository instance will be created to determine the network
 
754
        # name.
 
755
        client.add_success_response_with_body(
 
756
            "Bazaar-NG meta directory, format 1\n", 'ok')
 
757
        client.add_success_response_with_body(
 
758
            reference_format.get_format_string(), 'ok')
 
759
        # PackRepository wants to do a stat
 
760
        client.add_success_response('stat', '0', '65535')
 
761
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
762
            _client=client)
 
763
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
 
764
            _client=client)
 
765
        repo = bzrdir.open_repository()
 
766
        self.assertEqual(
 
767
            [('call', 'BzrDir.find_repositoryV3', ('quack/',)),
 
768
             ('call', 'BzrDir.find_repositoryV2', ('quack/',)),
 
769
             ('call', 'BzrDir.find_repository', ('quack/',)),
 
770
             ('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
 
771
             ('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
 
772
             ('call', 'stat', ('/quack/.bzr/repository',)),
 
773
             ],
 
774
            client._calls)
 
775
        self.assertEqual(network_name, repo._format.network_name())
 
776
 
 
777
    def test_backwards_compat_2(self):
 
778
        # fallback to find_repositoryV2
 
779
        reference_format = self.get_repo_format()
 
780
        network_name = reference_format.network_name()
 
781
        server_url = 'bzr://example.com/'
 
782
        self.permit_url(server_url)
 
783
        client = FakeClient(server_url)
 
784
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
 
785
        client.add_success_response('ok', '', 'no', 'no', 'no')
 
786
        # A real repository instance will be created to determine the network
 
787
        # name.
 
788
        client.add_success_response_with_body(
 
789
            "Bazaar-NG meta directory, format 1\n", 'ok')
 
790
        client.add_success_response_with_body(
 
791
            reference_format.get_format_string(), 'ok')
 
792
        # PackRepository wants to do a stat
 
793
        client.add_success_response('stat', '0', '65535')
 
794
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
795
            _client=client)
 
796
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
 
797
            _client=client)
 
798
        repo = bzrdir.open_repository()
 
799
        self.assertEqual(
 
800
            [('call', 'BzrDir.find_repositoryV3', ('quack/',)),
 
801
             ('call', 'BzrDir.find_repositoryV2', ('quack/',)),
 
802
             ('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
 
803
             ('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
 
804
             ('call', 'stat', ('/quack/.bzr/repository',)),
 
805
             ],
 
806
            client._calls)
 
807
        self.assertEqual(network_name, repo._format.network_name())
 
808
 
 
809
    def test_current_server(self):
 
810
        reference_format = self.get_repo_format()
 
811
        network_name = reference_format.network_name()
 
812
        transport = MemoryTransport()
 
813
        transport.mkdir('quack')
 
814
        transport = transport.clone('quack')
 
815
        client = FakeClient(transport.base)
 
816
        client.add_success_response('ok', '', 'no', 'no', 'no', network_name)
 
817
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
818
            _client=client)
 
819
        repo = bzrdir.open_repository()
 
820
        self.assertEqual(
 
821
            [('call', 'BzrDir.find_repositoryV3', ('quack/',))],
 
822
            client._calls)
 
823
        self.assertEqual(network_name, repo._format.network_name())
 
824
 
 
825
 
 
826
class TestBzrDirFormatInitializeEx(TestRemote):
 
827
 
 
828
    def test_success(self):
 
829
        """Simple test for typical successful call."""
 
830
        fmt = bzrdir.RemoteBzrDirFormat()
 
831
        default_format_name = BzrDirFormat.get_default_format().network_name()
 
832
        transport = self.get_transport()
 
833
        client = FakeClient(transport.base)
 
834
        client.add_expected_call(
 
835
            'BzrDirFormat.initialize_ex_1.16',
 
836
                (default_format_name, 'path', 'False', 'False', 'False', '',
 
837
                 '', '', '', 'False'),
 
838
            'success',
 
839
                ('.', 'no', 'no', 'yes', 'repo fmt', 'repo bzrdir fmt',
 
840
                 'bzrdir fmt', 'False', '', '', 'repo lock token'))
 
841
        # XXX: It would be better to call fmt.initialize_on_transport_ex, but
 
842
        # it's currently hard to test that without supplying a real remote
 
843
        # transport connected to a real server.
 
844
        result = fmt._initialize_on_transport_ex_rpc(client, 'path',
 
845
            transport, False, False, False, None, None, None, None, False)
 
846
        self.assertFinished(client)
 
847
 
 
848
    def test_error(self):
 
849
        """Error responses are translated, e.g. 'PermissionDenied' raises the
 
850
        corresponding error from the client.
 
851
        """
 
852
        fmt = bzrdir.RemoteBzrDirFormat()
 
853
        default_format_name = BzrDirFormat.get_default_format().network_name()
 
854
        transport = self.get_transport()
 
855
        client = FakeClient(transport.base)
 
856
        client.add_expected_call(
 
857
            'BzrDirFormat.initialize_ex_1.16',
 
858
                (default_format_name, 'path', 'False', 'False', 'False', '',
 
859
                 '', '', '', 'False'),
 
860
            'error',
 
861
                ('PermissionDenied', 'path', 'extra info'))
 
862
        # XXX: It would be better to call fmt.initialize_on_transport_ex, but
 
863
        # it's currently hard to test that without supplying a real remote
 
864
        # transport connected to a real server.
 
865
        err = self.assertRaises(errors.PermissionDenied,
 
866
            fmt._initialize_on_transport_ex_rpc, client, 'path', transport,
 
867
            False, False, False, None, None, None, None, False)
 
868
        self.assertEqual('path', err.path)
 
869
        self.assertEqual(': extra info', err.extra)
 
870
        self.assertFinished(client)
 
871
 
 
872
    def test_error_from_real_server(self):
 
873
        """Integration test for error translation."""
 
874
        transport = self.make_smart_server('foo')
 
875
        transport = transport.clone('no-such-path')
 
876
        fmt = bzrdir.RemoteBzrDirFormat()
 
877
        err = self.assertRaises(errors.NoSuchFile,
 
878
            fmt.initialize_on_transport_ex, transport, create_prefix=False)
479
879
 
480
880
 
481
881
class OldSmartClient(object):
506
906
        return OldSmartClient()
507
907
 
508
908
 
509
 
class RemoteBranchTestCase(tests.TestCase):
 
909
class RemoteBzrDirTestCase(TestRemote):
 
910
 
 
911
    def make_remote_bzrdir(self, transport, client):
 
912
        """Make a RemotebzrDir using 'client' as the _client."""
 
913
        return RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
914
            _client=client)
 
915
 
 
916
 
 
917
class RemoteBranchTestCase(RemoteBzrDirTestCase):
 
918
 
 
919
    def lock_remote_branch(self, branch):
 
920
        """Trick a RemoteBranch into thinking it is locked."""
 
921
        branch._lock_mode = 'w'
 
922
        branch._lock_count = 2
 
923
        branch._lock_token = 'branch token'
 
924
        branch._repo_lock_token = 'repo token'
 
925
        branch.repository._lock_mode = 'w'
 
926
        branch.repository._lock_count = 2
 
927
        branch.repository._lock_token = 'repo token'
510
928
 
511
929
    def make_remote_branch(self, transport, client):
512
930
        """Make a RemoteBranch using 'client' as its _SmartClient.
513
 
        
 
931
 
514
932
        A RemoteBzrDir and RemoteRepository will also be created to fill out
515
933
        the RemoteBranch, albeit with stub values for some of their attributes.
516
934
        """
517
935
        # we do not want bzrdir to make any remote calls, so use False as its
518
936
        # _client.  If it tries to make a remote call, this will fail
519
937
        # immediately.
520
 
        bzrdir = RemoteBzrDir(transport, _client=False)
 
938
        bzrdir = self.make_remote_bzrdir(transport, False)
521
939
        repo = RemoteRepository(bzrdir, None, _client=client)
522
 
        return RemoteBranch(bzrdir, repo, _client=client)
 
940
        branch_format = self.get_branch_format()
 
941
        format = RemoteBranchFormat(network_name=branch_format.network_name())
 
942
        return RemoteBranch(bzrdir, repo, _client=client, format=format)
 
943
 
 
944
 
 
945
class TestBranchGetParent(RemoteBranchTestCase):
 
946
 
 
947
    def test_no_parent(self):
 
948
        # in an empty branch we decode the response properly
 
949
        transport = MemoryTransport()
 
950
        client = FakeClient(transport.base)
 
951
        client.add_expected_call(
 
952
            'Branch.get_stacked_on_url', ('quack/',),
 
953
            'error', ('NotStacked',))
 
954
        client.add_expected_call(
 
955
            'Branch.get_parent', ('quack/',),
 
956
            'success', ('',))
 
957
        transport.mkdir('quack')
 
958
        transport = transport.clone('quack')
 
959
        branch = self.make_remote_branch(transport, client)
 
960
        result = branch.get_parent()
 
961
        self.assertFinished(client)
 
962
        self.assertEqual(None, result)
 
963
 
 
964
    def test_parent_relative(self):
 
965
        transport = MemoryTransport()
 
966
        client = FakeClient(transport.base)
 
967
        client.add_expected_call(
 
968
            'Branch.get_stacked_on_url', ('kwaak/',),
 
969
            'error', ('NotStacked',))
 
970
        client.add_expected_call(
 
971
            'Branch.get_parent', ('kwaak/',),
 
972
            'success', ('../foo/',))
 
973
        transport.mkdir('kwaak')
 
974
        transport = transport.clone('kwaak')
 
975
        branch = self.make_remote_branch(transport, client)
 
976
        result = branch.get_parent()
 
977
        self.assertEqual(transport.clone('../foo').base, result)
 
978
 
 
979
    def test_parent_absolute(self):
 
980
        transport = MemoryTransport()
 
981
        client = FakeClient(transport.base)
 
982
        client.add_expected_call(
 
983
            'Branch.get_stacked_on_url', ('kwaak/',),
 
984
            'error', ('NotStacked',))
 
985
        client.add_expected_call(
 
986
            'Branch.get_parent', ('kwaak/',),
 
987
            'success', ('http://foo/',))
 
988
        transport.mkdir('kwaak')
 
989
        transport = transport.clone('kwaak')
 
990
        branch = self.make_remote_branch(transport, client)
 
991
        result = branch.get_parent()
 
992
        self.assertEqual('http://foo/', result)
 
993
        self.assertFinished(client)
 
994
 
 
995
 
 
996
class TestBranchSetParentLocation(RemoteBranchTestCase):
 
997
 
 
998
    def test_no_parent(self):
 
999
        # We call the verb when setting parent to None
 
1000
        transport = MemoryTransport()
 
1001
        client = FakeClient(transport.base)
 
1002
        client.add_expected_call(
 
1003
            'Branch.get_stacked_on_url', ('quack/',),
 
1004
            'error', ('NotStacked',))
 
1005
        client.add_expected_call(
 
1006
            'Branch.set_parent_location', ('quack/', 'b', 'r', ''),
 
1007
            'success', ())
 
1008
        transport.mkdir('quack')
 
1009
        transport = transport.clone('quack')
 
1010
        branch = self.make_remote_branch(transport, client)
 
1011
        branch._lock_token = 'b'
 
1012
        branch._repo_lock_token = 'r'
 
1013
        branch._set_parent_location(None)
 
1014
        self.assertFinished(client)
 
1015
 
 
1016
    def test_parent(self):
 
1017
        transport = MemoryTransport()
 
1018
        client = FakeClient(transport.base)
 
1019
        client.add_expected_call(
 
1020
            'Branch.get_stacked_on_url', ('kwaak/',),
 
1021
            'error', ('NotStacked',))
 
1022
        client.add_expected_call(
 
1023
            'Branch.set_parent_location', ('kwaak/', 'b', 'r', 'foo'),
 
1024
            'success', ())
 
1025
        transport.mkdir('kwaak')
 
1026
        transport = transport.clone('kwaak')
 
1027
        branch = self.make_remote_branch(transport, client)
 
1028
        branch._lock_token = 'b'
 
1029
        branch._repo_lock_token = 'r'
 
1030
        branch._set_parent_location('foo')
 
1031
        self.assertFinished(client)
 
1032
 
 
1033
    def test_backwards_compat(self):
 
1034
        self.setup_smart_server_with_call_log()
 
1035
        branch = self.make_branch('.')
 
1036
        self.reset_smart_call_log()
 
1037
        verb = 'Branch.set_parent_location'
 
1038
        self.disable_verb(verb)
 
1039
        branch.set_parent('http://foo/')
 
1040
        self.assertLength(12, self.hpss_calls)
 
1041
 
 
1042
 
 
1043
class TestBranchGetTagsBytes(RemoteBranchTestCase):
 
1044
 
 
1045
    def test_backwards_compat(self):
 
1046
        self.setup_smart_server_with_call_log()
 
1047
        branch = self.make_branch('.')
 
1048
        self.reset_smart_call_log()
 
1049
        verb = 'Branch.get_tags_bytes'
 
1050
        self.disable_verb(verb)
 
1051
        branch.tags.get_tag_dict()
 
1052
        call_count = len([call for call in self.hpss_calls if
 
1053
            call.call.method == verb])
 
1054
        self.assertEqual(1, call_count)
 
1055
 
 
1056
    def test_trivial(self):
 
1057
        transport = MemoryTransport()
 
1058
        client = FakeClient(transport.base)
 
1059
        client.add_expected_call(
 
1060
            'Branch.get_stacked_on_url', ('quack/',),
 
1061
            'error', ('NotStacked',))
 
1062
        client.add_expected_call(
 
1063
            'Branch.get_tags_bytes', ('quack/',),
 
1064
            'success', ('',))
 
1065
        transport.mkdir('quack')
 
1066
        transport = transport.clone('quack')
 
1067
        branch = self.make_remote_branch(transport, client)
 
1068
        result = branch.tags.get_tag_dict()
 
1069
        self.assertFinished(client)
 
1070
        self.assertEqual({}, result)
 
1071
 
 
1072
 
 
1073
class TestBranchSetTagsBytes(RemoteBranchTestCase):
 
1074
 
 
1075
    def test_trivial(self):
 
1076
        transport = MemoryTransport()
 
1077
        client = FakeClient(transport.base)
 
1078
        client.add_expected_call(
 
1079
            'Branch.get_stacked_on_url', ('quack/',),
 
1080
            'error', ('NotStacked',))
 
1081
        client.add_expected_call(
 
1082
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
 
1083
            'success', ('',))
 
1084
        transport.mkdir('quack')
 
1085
        transport = transport.clone('quack')
 
1086
        branch = self.make_remote_branch(transport, client)
 
1087
        self.lock_remote_branch(branch)
 
1088
        branch._set_tags_bytes('tags bytes')
 
1089
        self.assertFinished(client)
 
1090
        self.assertEqual('tags bytes', client._calls[-1][-1])
 
1091
 
 
1092
    def test_backwards_compatible(self):
 
1093
        transport = MemoryTransport()
 
1094
        client = FakeClient(transport.base)
 
1095
        client.add_expected_call(
 
1096
            'Branch.get_stacked_on_url', ('quack/',),
 
1097
            'error', ('NotStacked',))
 
1098
        client.add_expected_call(
 
1099
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
 
1100
            'unknown', ('Branch.set_tags_bytes',))
 
1101
        transport.mkdir('quack')
 
1102
        transport = transport.clone('quack')
 
1103
        branch = self.make_remote_branch(transport, client)
 
1104
        self.lock_remote_branch(branch)
 
1105
        class StubRealBranch(object):
 
1106
            def __init__(self):
 
1107
                self.calls = []
 
1108
            def _set_tags_bytes(self, bytes):
 
1109
                self.calls.append(('set_tags_bytes', bytes))
 
1110
        real_branch = StubRealBranch()
 
1111
        branch._real_branch = real_branch
 
1112
        branch._set_tags_bytes('tags bytes')
 
1113
        # Call a second time, to exercise the 'remote version already inferred'
 
1114
        # code path.
 
1115
        branch._set_tags_bytes('tags bytes')
 
1116
        self.assertFinished(client)
 
1117
        self.assertEqual(
 
1118
            [('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
523
1119
 
524
1120
 
525
1121
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
538
1134
        transport = transport.clone('quack')
539
1135
        branch = self.make_remote_branch(transport, client)
540
1136
        result = branch.last_revision_info()
541
 
        client.finished_test()
 
1137
        self.assertFinished(client)
542
1138
        self.assertEqual((0, NULL_REVISION), result)
543
1139
 
544
1140
    def test_non_empty_branch(self):
559
1155
        self.assertEqual((2, revid), result)
560
1156
 
561
1157
 
562
 
class TestBranch_get_stacked_on_url(tests.TestCaseWithMemoryTransport):
 
1158
class TestBranch_get_stacked_on_url(TestRemote):
563
1159
    """Test Branch._get_stacked_on_url rpc"""
564
1160
 
565
1161
    def test_get_stacked_on_invalid_url(self):
566
 
        raise tests.KnownFailure('opening a branch requires the server to open the fallback repository')
567
 
        transport = FakeRemoteTransport('fakeremotetransport:///')
 
1162
        # test that asking for a stacked on url the server can't access works.
 
1163
        # This isn't perfect, but then as we're in the same process there
 
1164
        # really isn't anything we can do to be 100% sure that the server
 
1165
        # doesn't just open in - this test probably needs to be rewritten using
 
1166
        # a spawn()ed server.
 
1167
        stacked_branch = self.make_branch('stacked', format='1.9')
 
1168
        memory_branch = self.make_branch('base', format='1.9')
 
1169
        vfs_url = self.get_vfs_only_url('base')
 
1170
        stacked_branch.set_stacked_on_url(vfs_url)
 
1171
        transport = stacked_branch.bzrdir.root_transport
568
1172
        client = FakeClient(transport.base)
569
1173
        client.add_expected_call(
570
 
            'Branch.get_stacked_on_url', ('.',),
571
 
            'success', ('ok', 'file:///stacked/on'))
572
 
        bzrdir = RemoteBzrDir(transport, _client=client)
573
 
        branch = RemoteBranch(bzrdir, None, _client=client)
 
1174
            'Branch.get_stacked_on_url', ('stacked/',),
 
1175
            'success', ('ok', vfs_url))
 
1176
        # XXX: Multiple calls are bad, this second call documents what is
 
1177
        # today.
 
1178
        client.add_expected_call(
 
1179
            'Branch.get_stacked_on_url', ('stacked/',),
 
1180
            'success', ('ok', vfs_url))
 
1181
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
1182
            _client=client)
 
1183
        repo_fmt = remote.RemoteRepositoryFormat()
 
1184
        repo_fmt._custom_format = stacked_branch.repository._format
 
1185
        branch = RemoteBranch(bzrdir, RemoteRepository(bzrdir, repo_fmt),
 
1186
            _client=client)
574
1187
        result = branch.get_stacked_on_url()
575
 
        self.assertEqual(
576
 
            'file:///stacked/on', result)
 
1188
        self.assertEqual(vfs_url, result)
577
1189
 
578
1190
    def test_backwards_compatible(self):
579
1191
        # like with bzr1.6 with no Branch.get_stacked_on_url rpc
581
1193
        stacked_branch = self.make_branch('stacked', format='1.6')
582
1194
        stacked_branch.set_stacked_on_url('../base')
583
1195
        client = FakeClient(self.get_url())
584
 
        client.add_expected_call(
585
 
            'BzrDir.open_branch', ('stacked/',),
586
 
            'success', ('ok', ''))
587
 
        client.add_expected_call(
588
 
            'BzrDir.find_repositoryV2', ('stacked/',),
589
 
            'success', ('ok', '', 'no', 'no', 'no'))
 
1196
        branch_network_name = self.get_branch_format().network_name()
 
1197
        client.add_expected_call(
 
1198
            'BzrDir.open_branchV3', ('stacked/',),
 
1199
            'success', ('branch', branch_network_name))
 
1200
        client.add_expected_call(
 
1201
            'BzrDir.find_repositoryV3', ('stacked/',),
 
1202
            'success', ('ok', '', 'no', 'no', 'yes',
 
1203
                stacked_branch.repository._format.network_name()))
590
1204
        # called twice, once from constructor and then again by us
591
1205
        client.add_expected_call(
592
1206
            'Branch.get_stacked_on_url', ('stacked/',),
596
1210
            'unknown', ('Branch.get_stacked_on_url',))
597
1211
        # this will also do vfs access, but that goes direct to the transport
598
1212
        # and isn't seen by the FakeClient.
599
 
        bzrdir = RemoteBzrDir(self.get_transport('stacked'), _client=client)
 
1213
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
 
1214
            remote.RemoteBzrDirFormat(), _client=client)
600
1215
        branch = bzrdir.open_branch()
601
1216
        result = branch.get_stacked_on_url()
602
1217
        self.assertEqual('../base', result)
603
 
        client.finished_test()
 
1218
        self.assertFinished(client)
604
1219
        # it's in the fallback list both for the RemoteRepository and its vfs
605
1220
        # repository
606
1221
        self.assertEqual(1, len(branch.repository._fallback_repositories))
608
1223
            len(branch.repository._real_repository._fallback_repositories))
609
1224
 
610
1225
    def test_get_stacked_on_real_branch(self):
611
 
        base_branch = self.make_branch('base', format='1.6')
612
 
        stacked_branch = self.make_branch('stacked', format='1.6')
 
1226
        base_branch = self.make_branch('base')
 
1227
        stacked_branch = self.make_branch('stacked')
613
1228
        stacked_branch.set_stacked_on_url('../base')
 
1229
        reference_format = self.get_repo_format()
 
1230
        network_name = reference_format.network_name()
614
1231
        client = FakeClient(self.get_url())
615
 
        client.add_expected_call(
616
 
            'BzrDir.open_branch', ('stacked/',),
617
 
            'success', ('ok', ''))
618
 
        client.add_expected_call(
619
 
            'BzrDir.find_repositoryV2', ('stacked/',),
620
 
            'success', ('ok', '', 'no', 'no', 'no'))
 
1232
        branch_network_name = self.get_branch_format().network_name()
 
1233
        client.add_expected_call(
 
1234
            'BzrDir.open_branchV3', ('stacked/',),
 
1235
            'success', ('branch', branch_network_name))
 
1236
        client.add_expected_call(
 
1237
            'BzrDir.find_repositoryV3', ('stacked/',),
 
1238
            'success', ('ok', '', 'yes', 'no', 'yes', network_name))
621
1239
        # called twice, once from constructor and then again by us
622
1240
        client.add_expected_call(
623
1241
            'Branch.get_stacked_on_url', ('stacked/',),
625
1243
        client.add_expected_call(
626
1244
            'Branch.get_stacked_on_url', ('stacked/',),
627
1245
            'success', ('ok', '../base'))
628
 
        bzrdir = RemoteBzrDir(self.get_transport('stacked'), _client=client)
 
1246
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
 
1247
            remote.RemoteBzrDirFormat(), _client=client)
629
1248
        branch = bzrdir.open_branch()
630
1249
        result = branch.get_stacked_on_url()
631
1250
        self.assertEqual('../base', result)
632
 
        client.finished_test()
633
 
        # it's in the fallback list both for the RemoteRepository and its vfs
634
 
        # repository
 
1251
        self.assertFinished(client)
 
1252
        # it's in the fallback list both for the RemoteRepository.
635
1253
        self.assertEqual(1, len(branch.repository._fallback_repositories))
636
 
        self.assertEqual(1,
637
 
            len(branch.repository._real_repository._fallback_repositories))
 
1254
        # And we haven't had to construct a real repository.
 
1255
        self.assertEqual(None, branch.repository._real_repository)
638
1256
 
639
1257
 
640
1258
class TestBranchSetLastRevision(RemoteBranchTestCase):
654
1272
            'Branch.lock_write', ('branch/', '', ''),
655
1273
            'success', ('ok', 'branch token', 'repo token'))
656
1274
        client.add_expected_call(
 
1275
            'Branch.last_revision_info',
 
1276
            ('branch/',),
 
1277
            'success', ('ok', '0', 'null:'))
 
1278
        client.add_expected_call(
657
1279
            'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'null:',),
658
1280
            'success', ('ok',))
659
1281
        client.add_expected_call(
667
1289
        result = branch.set_revision_history([])
668
1290
        branch.unlock()
669
1291
        self.assertEqual(None, result)
670
 
        client.finished_test()
 
1292
        self.assertFinished(client)
671
1293
 
672
1294
    def test_set_nonempty(self):
673
1295
        # set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
684
1306
            'Branch.lock_write', ('branch/', '', ''),
685
1307
            'success', ('ok', 'branch token', 'repo token'))
686
1308
        client.add_expected_call(
 
1309
            'Branch.last_revision_info',
 
1310
            ('branch/',),
 
1311
            'success', ('ok', '0', 'null:'))
 
1312
        lines = ['rev-id2']
 
1313
        encoded_body = bz2.compress('\n'.join(lines))
 
1314
        client.add_success_response_with_body(encoded_body, 'ok')
 
1315
        client.add_expected_call(
687
1316
            'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'rev-id2',),
688
1317
            'success', ('ok',))
689
1318
        client.add_expected_call(
698
1327
        result = branch.set_revision_history(['rev-id1', 'rev-id2'])
699
1328
        branch.unlock()
700
1329
        self.assertEqual(None, result)
701
 
        client.finished_test()
 
1330
        self.assertFinished(client)
702
1331
 
703
1332
    def test_no_such_revision(self):
704
1333
        transport = MemoryTransport()
713
1342
            'Branch.lock_write', ('branch/', '', ''),
714
1343
            'success', ('ok', 'branch token', 'repo token'))
715
1344
        client.add_expected_call(
 
1345
            'Branch.last_revision_info',
 
1346
            ('branch/',),
 
1347
            'success', ('ok', '0', 'null:'))
 
1348
        # get_graph calls to construct the revision history, for the set_rh
 
1349
        # hook
 
1350
        lines = ['rev-id']
 
1351
        encoded_body = bz2.compress('\n'.join(lines))
 
1352
        client.add_success_response_with_body(encoded_body, 'ok')
 
1353
        client.add_expected_call(
716
1354
            'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'rev-id',),
717
1355
            'error', ('NoSuchRevision', 'rev-id'))
718
1356
        client.add_expected_call(
724
1362
        self.assertRaises(
725
1363
            errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
726
1364
        branch.unlock()
727
 
        client.finished_test()
 
1365
        self.assertFinished(client)
728
1366
 
729
1367
    def test_tip_change_rejected(self):
730
1368
        """TipChangeRejected responses cause a TipChangeRejected exception to
743
1381
            'Branch.lock_write', ('branch/', '', ''),
744
1382
            'success', ('ok', 'branch token', 'repo token'))
745
1383
        client.add_expected_call(
 
1384
            'Branch.last_revision_info',
 
1385
            ('branch/',),
 
1386
            'success', ('ok', '0', 'null:'))
 
1387
        lines = ['rev-id']
 
1388
        encoded_body = bz2.compress('\n'.join(lines))
 
1389
        client.add_success_response_with_body(encoded_body, 'ok')
 
1390
        client.add_expected_call(
746
1391
            'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'rev-id',),
747
1392
            'error', ('TipChangeRejected', rejection_msg_utf8))
748
1393
        client.add_expected_call(
751
1396
        branch = self.make_remote_branch(transport, client)
752
1397
        branch._ensure_real = lambda: None
753
1398
        branch.lock_write()
754
 
        self.addCleanup(branch.unlock)
755
1399
        # The 'TipChangeRejected' error response triggered by calling
756
1400
        # set_revision_history causes a TipChangeRejected exception.
757
1401
        err = self.assertRaises(
761
1405
        self.assertIsInstance(err.msg, unicode)
762
1406
        self.assertEqual(rejection_msg_unicode, err.msg)
763
1407
        branch.unlock()
764
 
        client.finished_test()
 
1408
        self.assertFinished(client)
765
1409
 
766
1410
 
767
1411
class TestBranchSetLastRevisionInfo(RemoteBranchTestCase):
777
1421
        client.add_error_response('NotStacked')
778
1422
        # lock_write
779
1423
        client.add_success_response('ok', 'branch token', 'repo token')
 
1424
        # query the current revision
 
1425
        client.add_success_response('ok', '0', 'null:')
780
1426
        # set_last_revision
781
1427
        client.add_success_response('ok')
782
1428
        # unlock
788
1434
        client._calls = []
789
1435
        result = branch.set_last_revision_info(1234, 'a-revision-id')
790
1436
        self.assertEqual(
791
 
            [('call', 'Branch.set_last_revision_info',
 
1437
            [('call', 'Branch.last_revision_info', ('branch/',)),
 
1438
             ('call', 'Branch.set_last_revision_info',
792
1439
                ('branch/', 'branch token', 'repo token',
793
1440
                 '1234', 'a-revision-id'))],
794
1441
            client._calls)
818
1465
            errors.NoSuchRevision, branch.set_last_revision_info, 123, 'revid')
819
1466
        branch.unlock()
820
1467
 
821
 
    def lock_remote_branch(self, branch):
822
 
        """Trick a RemoteBranch into thinking it is locked."""
823
 
        branch._lock_mode = 'w'
824
 
        branch._lock_count = 2
825
 
        branch._lock_token = 'branch token'
826
 
        branch._repo_lock_token = 'repo token'
827
 
        branch.repository._lock_mode = 'w'
828
 
        branch.repository._lock_count = 2
829
 
        branch.repository._lock_token = 'repo token'
830
 
 
831
1468
    def test_backwards_compatibility(self):
832
1469
        """If the server does not support the Branch.set_last_revision_info
833
1470
        verb (which is new in 1.4), then the client falls back to VFS methods.
848
1485
            'Branch.get_stacked_on_url', ('branch/',),
849
1486
            'error', ('NotStacked',))
850
1487
        client.add_expected_call(
 
1488
            'Branch.last_revision_info',
 
1489
            ('branch/',),
 
1490
            'success', ('ok', '0', 'null:'))
 
1491
        client.add_expected_call(
851
1492
            'Branch.set_last_revision_info',
852
1493
            ('branch/', 'branch token', 'repo token', '1234', 'a-revision-id',),
853
1494
            'unknown', 'Branch.set_last_revision_info')
870
1511
        self.assertEqual(
871
1512
            [('set_last_revision_info', 1234, 'a-revision-id')],
872
1513
            real_branch.calls)
873
 
        client.finished_test()
 
1514
        self.assertFinished(client)
874
1515
 
875
1516
    def test_unexpected_error(self):
876
1517
        # If the server sends an error the client doesn't understand, it gets
931
1572
        self.assertEqual('rejection message', err.msg)
932
1573
 
933
1574
 
934
 
class TestBranchControlGetBranchConf(tests.TestCaseWithMemoryTransport):
935
 
    """Getting the branch configuration should use an abstract method not vfs.
936
 
    """
 
1575
class TestBranchGetSetConfig(RemoteBranchTestCase):
937
1576
 
938
1577
    def test_get_branch_conf(self):
939
 
        raise tests.KnownFailure('branch.conf is not retrieved by get_config_file')
940
 
        ## # We should see that branch.get_config() does a single rpc to get the
941
 
        ## # remote configuration file, abstracting away where that is stored on
942
 
        ## # the server.  However at the moment it always falls back to using the
943
 
        ## # vfs, and this would need some changes in config.py.
944
 
 
945
 
        ## # in an empty branch we decode the response properly
946
 
        ## client = FakeClient([(('ok', ), '# config file body')], self.get_url())
947
 
        ## # we need to make a real branch because the remote_branch.control_files
948
 
        ## # will trigger _ensure_real.
949
 
        ## branch = self.make_branch('quack')
950
 
        ## transport = branch.bzrdir.root_transport
951
 
        ## # we do not want bzrdir to make any remote calls
952
 
        ## bzrdir = RemoteBzrDir(transport, _client=False)
953
 
        ## branch = RemoteBranch(bzrdir, None, _client=client)
954
 
        ## config = branch.get_config()
955
 
        ## self.assertEqual(
956
 
        ##     [('call_expecting_body', 'Branch.get_config_file', ('quack/',))],
957
 
        ##     client._calls)
 
1578
        # in an empty branch we decode the response properly
 
1579
        client = FakeClient()
 
1580
        client.add_expected_call(
 
1581
            'Branch.get_stacked_on_url', ('memory:///',),
 
1582
            'error', ('NotStacked',),)
 
1583
        client.add_success_response_with_body('# config file body', 'ok')
 
1584
        transport = MemoryTransport()
 
1585
        branch = self.make_remote_branch(transport, client)
 
1586
        config = branch.get_config()
 
1587
        config.has_explicit_nickname()
 
1588
        self.assertEqual(
 
1589
            [('call', 'Branch.get_stacked_on_url', ('memory:///',)),
 
1590
             ('call_expecting_body', 'Branch.get_config_file', ('memory:///',))],
 
1591
            client._calls)
 
1592
 
 
1593
    def test_get_multi_line_branch_conf(self):
 
1594
        # Make sure that multiple-line branch.conf files are supported
 
1595
        #
 
1596
        # https://bugs.edge.launchpad.net/bzr/+bug/354075
 
1597
        client = FakeClient()
 
1598
        client.add_expected_call(
 
1599
            'Branch.get_stacked_on_url', ('memory:///',),
 
1600
            'error', ('NotStacked',),)
 
1601
        client.add_success_response_with_body('a = 1\nb = 2\nc = 3\n', 'ok')
 
1602
        transport = MemoryTransport()
 
1603
        branch = self.make_remote_branch(transport, client)
 
1604
        config = branch.get_config()
 
1605
        self.assertEqual(u'2', config.get_user_option('b'))
 
1606
 
 
1607
    def test_set_option(self):
 
1608
        client = FakeClient()
 
1609
        client.add_expected_call(
 
1610
            'Branch.get_stacked_on_url', ('memory:///',),
 
1611
            'error', ('NotStacked',),)
 
1612
        client.add_expected_call(
 
1613
            'Branch.lock_write', ('memory:///', '', ''),
 
1614
            'success', ('ok', 'branch token', 'repo token'))
 
1615
        client.add_expected_call(
 
1616
            'Branch.set_config_option', ('memory:///', 'branch token',
 
1617
            'repo token', 'foo', 'bar', ''),
 
1618
            'success', ())
 
1619
        client.add_expected_call(
 
1620
            'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
 
1621
            'success', ('ok',))
 
1622
        transport = MemoryTransport()
 
1623
        branch = self.make_remote_branch(transport, client)
 
1624
        branch.lock_write()
 
1625
        config = branch._get_config()
 
1626
        config.set_option('foo', 'bar')
 
1627
        branch.unlock()
 
1628
        self.assertFinished(client)
 
1629
 
 
1630
    def test_backwards_compat_set_option(self):
 
1631
        self.setup_smart_server_with_call_log()
 
1632
        branch = self.make_branch('.')
 
1633
        verb = 'Branch.set_config_option'
 
1634
        self.disable_verb(verb)
 
1635
        branch.lock_write()
 
1636
        self.addCleanup(branch.unlock)
 
1637
        self.reset_smart_call_log()
 
1638
        branch._get_config().set_option('value', 'name')
 
1639
        self.assertLength(10, self.hpss_calls)
 
1640
        self.assertEqual('value', branch._get_config().get_option('name'))
958
1641
 
959
1642
 
960
1643
class TestBranchLockWrite(RemoteBranchTestCase):
972
1655
        transport = transport.clone('quack')
973
1656
        branch = self.make_remote_branch(transport, client)
974
1657
        self.assertRaises(errors.UnlockableTransport, branch.lock_write)
975
 
        client.finished_test()
 
1658
        self.assertFinished(client)
 
1659
 
 
1660
 
 
1661
class TestBzrDirGetSetConfig(RemoteBzrDirTestCase):
 
1662
 
 
1663
    def test__get_config(self):
 
1664
        client = FakeClient()
 
1665
        client.add_success_response_with_body('default_stack_on = /\n', 'ok')
 
1666
        transport = MemoryTransport()
 
1667
        bzrdir = self.make_remote_bzrdir(transport, client)
 
1668
        config = bzrdir.get_config()
 
1669
        self.assertEqual('/', config.get_default_stack_on())
 
1670
        self.assertEqual(
 
1671
            [('call_expecting_body', 'BzrDir.get_config_file', ('memory:///',))],
 
1672
            client._calls)
 
1673
 
 
1674
    def test_set_option_uses_vfs(self):
 
1675
        self.setup_smart_server_with_call_log()
 
1676
        bzrdir = self.make_bzrdir('.')
 
1677
        self.reset_smart_call_log()
 
1678
        config = bzrdir.get_config()
 
1679
        config.set_default_stack_on('/')
 
1680
        self.assertLength(3, self.hpss_calls)
 
1681
 
 
1682
    def test_backwards_compat_get_option(self):
 
1683
        self.setup_smart_server_with_call_log()
 
1684
        bzrdir = self.make_bzrdir('.')
 
1685
        verb = 'BzrDir.get_config_file'
 
1686
        self.disable_verb(verb)
 
1687
        self.reset_smart_call_log()
 
1688
        self.assertEqual(None,
 
1689
            bzrdir._get_config().get_option('default_stack_on'))
 
1690
        self.assertLength(3, self.hpss_calls)
976
1691
 
977
1692
 
978
1693
class TestTransportIsReadonly(tests.TestCase):
999
1714
 
1000
1715
    def test_error_from_old_server(self):
1001
1716
        """bzr 0.15 and earlier servers don't recognise the is_readonly verb.
1002
 
        
 
1717
 
1003
1718
        Clients should treat it as a "no" response, because is_readonly is only
1004
1719
        advisory anyway (a transport could be read-write, but then the
1005
1720
        underlying filesystem could be readonly anyway).
1014
1729
            client._calls)
1015
1730
 
1016
1731
 
1017
 
class TestRemoteRepository(tests.TestCase):
 
1732
class TestTransportMkdir(tests.TestCase):
 
1733
 
 
1734
    def test_permissiondenied(self):
 
1735
        client = FakeClient()
 
1736
        client.add_error_response('PermissionDenied', 'remote path', 'extra')
 
1737
        transport = RemoteTransport('bzr://example.com/', medium=False,
 
1738
                                    _client=client)
 
1739
        exc = self.assertRaises(
 
1740
            errors.PermissionDenied, transport.mkdir, 'client path')
 
1741
        expected_error = errors.PermissionDenied('/client path', 'extra')
 
1742
        self.assertEqual(expected_error, exc)
 
1743
 
 
1744
 
 
1745
class TestRemoteSSHTransportAuthentication(tests.TestCaseInTempDir):
 
1746
 
 
1747
    def test_defaults_to_none(self):
 
1748
        t = RemoteSSHTransport('bzr+ssh://example.com')
 
1749
        self.assertIs(None, t._get_credentials()[0])
 
1750
 
 
1751
    def test_uses_authentication_config(self):
 
1752
        conf = config.AuthenticationConfig()
 
1753
        conf._get_config().update(
 
1754
            {'bzr+sshtest': {'scheme': 'ssh', 'user': 'bar', 'host':
 
1755
            'example.com'}})
 
1756
        conf._save()
 
1757
        t = RemoteSSHTransport('bzr+ssh://example.com')
 
1758
        self.assertEqual('bar', t._get_credentials()[0])
 
1759
 
 
1760
 
 
1761
class TestRemoteRepository(TestRemote):
1018
1762
    """Base for testing RemoteRepository protocol usage.
1019
 
    
1020
 
    These tests contain frozen requests and responses.  We want any changes to 
 
1763
 
 
1764
    These tests contain frozen requests and responses.  We want any changes to
1021
1765
    what is sent or expected to be require a thoughtful update to these tests
1022
1766
    because they might break compatibility with different-versioned servers.
1023
1767
    """
1024
1768
 
1025
1769
    def setup_fake_client_and_repository(self, transport_path):
1026
1770
        """Create the fake client and repository for testing with.
1027
 
        
 
1771
 
1028
1772
        There's no real server here; we just have canned responses sent
1029
1773
        back one by one.
1030
 
        
 
1774
 
1031
1775
        :param transport_path: Path below the root of the MemoryTransport
1032
1776
            where the repository will be created.
1033
1777
        """
1036
1780
        client = FakeClient(transport.base)
1037
1781
        transport = transport.clone(transport_path)
1038
1782
        # we do not want bzrdir to make any remote calls
1039
 
        bzrdir = RemoteBzrDir(transport, _client=False)
 
1783
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
1784
            _client=False)
1040
1785
        repo = RemoteRepository(bzrdir, None, _client=client)
1041
1786
        return repo, client
1042
1787
 
1043
1788
 
 
1789
def remoted_description(format):
 
1790
    return 'Remote: ' + format.get_format_description()
 
1791
 
 
1792
 
 
1793
class TestBranchFormat(tests.TestCase):
 
1794
 
 
1795
    def test_get_format_description(self):
 
1796
        remote_format = RemoteBranchFormat()
 
1797
        real_format = branch.BranchFormat.get_default_format()
 
1798
        remote_format._network_name = real_format.network_name()
 
1799
        self.assertEqual(remoted_description(real_format),
 
1800
            remote_format.get_format_description())
 
1801
 
 
1802
 
 
1803
class TestRepositoryFormat(TestRemoteRepository):
 
1804
 
 
1805
    def test_fast_delta(self):
 
1806
        true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
 
1807
        true_format = RemoteRepositoryFormat()
 
1808
        true_format._network_name = true_name
 
1809
        self.assertEqual(True, true_format.fast_deltas)
 
1810
        false_name = pack_repo.RepositoryFormatKnitPack1().network_name()
 
1811
        false_format = RemoteRepositoryFormat()
 
1812
        false_format._network_name = false_name
 
1813
        self.assertEqual(False, false_format.fast_deltas)
 
1814
 
 
1815
    def test_get_format_description(self):
 
1816
        remote_repo_format = RemoteRepositoryFormat()
 
1817
        real_format = repository.RepositoryFormat.get_default_format()
 
1818
        remote_repo_format._network_name = real_format.network_name()
 
1819
        self.assertEqual(remoted_description(real_format),
 
1820
            remote_repo_format.get_format_description())
 
1821
 
 
1822
 
1044
1823
class TestRepositoryGatherStats(TestRemoteRepository):
1045
1824
 
1046
1825
    def test_revid_none(self):
1102
1881
class TestRepositoryGetGraph(TestRemoteRepository):
1103
1882
 
1104
1883
    def test_get_graph(self):
1105
 
        # get_graph returns a graph with the repository as the
1106
 
        # parents_provider.
 
1884
        # get_graph returns a graph with a custom parents provider.
1107
1885
        transport_path = 'quack'
1108
1886
        repo, client = self.setup_fake_client_and_repository(transport_path)
1109
1887
        graph = repo.get_graph()
1110
 
        self.assertEqual(graph._parents_provider, repo)
 
1888
        self.assertNotEqual(graph._parents_provider, repo)
1111
1889
 
1112
1890
 
1113
1891
class TestRepositoryGetParentMap(TestRemoteRepository):
1135
1913
        self.assertEqual({r1: (NULL_REVISION,)}, parents)
1136
1914
        self.assertEqual(
1137
1915
            [('call_with_body_bytes_expecting_body',
1138
 
              'Repository.get_parent_map', ('quack/', r2), '\n\n0')],
 
1916
              'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
 
1917
              '\n\n0')],
1139
1918
            client._calls)
1140
1919
        repo.unlock()
1141
1920
        # now we call again, and it should use the second response.
1145
1924
        self.assertEqual({r1: (NULL_REVISION,)}, parents)
1146
1925
        self.assertEqual(
1147
1926
            [('call_with_body_bytes_expecting_body',
1148
 
              'Repository.get_parent_map', ('quack/', r2), '\n\n0'),
 
1927
              'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
 
1928
              '\n\n0'),
1149
1929
             ('call_with_body_bytes_expecting_body',
1150
 
              'Repository.get_parent_map', ('quack/', r1), '\n\n0'),
 
1930
              'Repository.get_parent_map', ('quack/', 'include-missing:', r1),
 
1931
              '\n\n0'),
1151
1932
            ],
1152
1933
            client._calls)
1153
1934
        repo.unlock()
1154
1935
 
1155
1936
    def test_get_parent_map_reconnects_if_unknown_method(self):
1156
1937
        transport_path = 'quack'
 
1938
        rev_id = 'revision-id'
1157
1939
        repo, client = self.setup_fake_client_and_repository(transport_path)
1158
 
        client.add_unknown_method_response('Repository,get_parent_map')
1159
 
        client.add_success_response_with_body('', 'ok')
 
1940
        client.add_unknown_method_response('Repository.get_parent_map')
 
1941
        client.add_success_response_with_body(rev_id, 'ok')
1160
1942
        self.assertFalse(client._medium._is_remote_before((1, 2)))
1161
 
        rev_id = 'revision-id'
1162
 
        expected_deprecations = [
1163
 
            'bzrlib.remote.RemoteRepository.get_revision_graph was deprecated '
1164
 
            'in version 1.4.']
1165
 
        parents = self.callDeprecated(
1166
 
            expected_deprecations, repo.get_parent_map, [rev_id])
 
1943
        parents = repo.get_parent_map([rev_id])
1167
1944
        self.assertEqual(
1168
1945
            [('call_with_body_bytes_expecting_body',
1169
 
              'Repository.get_parent_map', ('quack/', rev_id), '\n\n0'),
 
1946
              'Repository.get_parent_map', ('quack/', 'include-missing:',
 
1947
              rev_id), '\n\n0'),
1170
1948
             ('disconnect medium',),
1171
1949
             ('call_expecting_body', 'Repository.get_revision_graph',
1172
1950
              ('quack/', ''))],
1173
1951
            client._calls)
1174
1952
        # The medium is now marked as being connected to an older server
1175
1953
        self.assertTrue(client._medium._is_remote_before((1, 2)))
 
1954
        self.assertEqual({rev_id: ('null:',)}, parents)
1176
1955
 
1177
1956
    def test_get_parent_map_fallback_parentless_node(self):
1178
1957
        """get_parent_map falls back to get_revision_graph on old servers.  The
1190
1969
        repo, client = self.setup_fake_client_and_repository(transport_path)
1191
1970
        client.add_success_response_with_body(rev_id, 'ok')
1192
1971
        client._medium._remember_remote_is_before((1, 2))
1193
 
        expected_deprecations = [
1194
 
            'bzrlib.remote.RemoteRepository.get_revision_graph was deprecated '
1195
 
            'in version 1.4.']
1196
 
        parents = self.callDeprecated(
1197
 
            expected_deprecations, repo.get_parent_map, [rev_id])
 
1972
        parents = repo.get_parent_map([rev_id])
1198
1973
        self.assertEqual(
1199
1974
            [('call_expecting_body', 'Repository.get_revision_graph',
1200
1975
             ('quack/', ''))],
1208
1983
            errors.UnexpectedSmartServerResponse,
1209
1984
            repo.get_parent_map, ['a-revision-id'])
1210
1985
 
 
1986
    def test_get_parent_map_negative_caches_missing_keys(self):
 
1987
        self.setup_smart_server_with_call_log()
 
1988
        repo = self.make_repository('foo')
 
1989
        self.assertIsInstance(repo, RemoteRepository)
 
1990
        repo.lock_read()
 
1991
        self.addCleanup(repo.unlock)
 
1992
        self.reset_smart_call_log()
 
1993
        graph = repo.get_graph()
 
1994
        self.assertEqual({},
 
1995
            graph.get_parent_map(['some-missing', 'other-missing']))
 
1996
        self.assertLength(1, self.hpss_calls)
 
1997
        # No call if we repeat this
 
1998
        self.reset_smart_call_log()
 
1999
        graph = repo.get_graph()
 
2000
        self.assertEqual({},
 
2001
            graph.get_parent_map(['some-missing', 'other-missing']))
 
2002
        self.assertLength(0, self.hpss_calls)
 
2003
        # Asking for more unknown keys makes a request.
 
2004
        self.reset_smart_call_log()
 
2005
        graph = repo.get_graph()
 
2006
        self.assertEqual({},
 
2007
            graph.get_parent_map(['some-missing', 'other-missing',
 
2008
                'more-missing']))
 
2009
        self.assertLength(1, self.hpss_calls)
 
2010
 
 
2011
    def disableExtraResults(self):
 
2012
        self.overrideAttr(SmartServerRepositoryGetParentMap,
 
2013
                          'no_extra_results', True)
 
2014
 
 
2015
    def test_null_cached_missing_and_stop_key(self):
 
2016
        self.setup_smart_server_with_call_log()
 
2017
        # Make a branch with a single revision.
 
2018
        builder = self.make_branch_builder('foo')
 
2019
        builder.start_series()
 
2020
        builder.build_snapshot('first', None, [
 
2021
            ('add', ('', 'root-id', 'directory', ''))])
 
2022
        builder.finish_series()
 
2023
        branch = builder.get_branch()
 
2024
        repo = branch.repository
 
2025
        self.assertIsInstance(repo, RemoteRepository)
 
2026
        # Stop the server from sending extra results.
 
2027
        self.disableExtraResults()
 
2028
        repo.lock_read()
 
2029
        self.addCleanup(repo.unlock)
 
2030
        self.reset_smart_call_log()
 
2031
        graph = repo.get_graph()
 
2032
        # Query for 'first' and 'null:'.  Because 'null:' is a parent of
 
2033
        # 'first' it will be a candidate for the stop_keys of subsequent
 
2034
        # requests, and because 'null:' was queried but not returned it will be
 
2035
        # cached as missing.
 
2036
        self.assertEqual({'first': ('null:',)},
 
2037
            graph.get_parent_map(['first', 'null:']))
 
2038
        # Now query for another key.  This request will pass along a recipe of
 
2039
        # start and stop keys describing the already cached results, and this
 
2040
        # recipe's revision count must be correct (or else it will trigger an
 
2041
        # error from the server).
 
2042
        self.assertEqual({}, graph.get_parent_map(['another-key']))
 
2043
        # This assertion guards against disableExtraResults silently failing to
 
2044
        # work, thus invalidating the test.
 
2045
        self.assertLength(2, self.hpss_calls)
 
2046
 
 
2047
    def test_get_parent_map_gets_ghosts_from_result(self):
 
2048
        # asking for a revision should negatively cache close ghosts in its
 
2049
        # ancestry.
 
2050
        self.setup_smart_server_with_call_log()
 
2051
        tree = self.make_branch_and_memory_tree('foo')
 
2052
        tree.lock_write()
 
2053
        try:
 
2054
            builder = treebuilder.TreeBuilder()
 
2055
            builder.start_tree(tree)
 
2056
            builder.build([])
 
2057
            builder.finish_tree()
 
2058
            tree.set_parent_ids(['non-existant'], allow_leftmost_as_ghost=True)
 
2059
            rev_id = tree.commit('')
 
2060
        finally:
 
2061
            tree.unlock()
 
2062
        tree.lock_read()
 
2063
        self.addCleanup(tree.unlock)
 
2064
        repo = tree.branch.repository
 
2065
        self.assertIsInstance(repo, RemoteRepository)
 
2066
        # ask for rev_id
 
2067
        repo.get_parent_map([rev_id])
 
2068
        self.reset_smart_call_log()
 
2069
        # Now asking for rev_id's ghost parent should not make calls
 
2070
        self.assertEqual({}, repo.get_parent_map(['non-existant']))
 
2071
        self.assertLength(0, self.hpss_calls)
 
2072
 
 
2073
 
 
2074
class TestGetParentMapAllowsNew(tests.TestCaseWithTransport):
 
2075
 
 
2076
    def test_allows_new_revisions(self):
 
2077
        """get_parent_map's results can be updated by commit."""
 
2078
        smart_server = test_server.SmartTCPServer_for_testing()
 
2079
        self.start_server(smart_server)
 
2080
        self.make_branch('branch')
 
2081
        branch = Branch.open(smart_server.get_url() + '/branch')
 
2082
        tree = branch.create_checkout('tree', lightweight=True)
 
2083
        tree.lock_write()
 
2084
        self.addCleanup(tree.unlock)
 
2085
        graph = tree.branch.repository.get_graph()
 
2086
        # This provides an opportunity for the missing rev-id to be cached.
 
2087
        self.assertEqual({}, graph.get_parent_map(['rev1']))
 
2088
        tree.commit('message', rev_id='rev1')
 
2089
        graph = tree.branch.repository.get_graph()
 
2090
        self.assertEqual({'rev1': ('null:',)}, graph.get_parent_map(['rev1']))
 
2091
 
1211
2092
 
1212
2093
class TestRepositoryGetRevisionGraph(TestRemoteRepository):
1213
 
    
 
2094
 
1214
2095
    def test_null_revision(self):
1215
2096
        # a null revision has the predictable result {}, we should have no wire
1216
2097
        # traffic when calling it with this argument
1217
2098
        transport_path = 'empty'
1218
2099
        repo, client = self.setup_fake_client_and_repository(transport_path)
1219
2100
        client.add_success_response('notused')
1220
 
        result = self.applyDeprecated(one_four, repo.get_revision_graph,
1221
 
            NULL_REVISION)
 
2101
        # actual RemoteRepository.get_revision_graph is gone, but there's an
 
2102
        # equivalent private method for testing
 
2103
        result = repo._get_revision_graph(NULL_REVISION)
1222
2104
        self.assertEqual([], client._calls)
1223
2105
        self.assertEqual({}, result)
1224
2106
 
1232
2114
        transport_path = 'sinhala'
1233
2115
        repo, client = self.setup_fake_client_and_repository(transport_path)
1234
2116
        client.add_success_response_with_body(encoded_body, 'ok')
1235
 
        result = self.applyDeprecated(one_four, repo.get_revision_graph)
 
2117
        # actual RemoteRepository.get_revision_graph is gone, but there's an
 
2118
        # equivalent private method for testing
 
2119
        result = repo._get_revision_graph(None)
1236
2120
        self.assertEqual(
1237
2121
            [('call_expecting_body', 'Repository.get_revision_graph',
1238
2122
             ('sinhala/', ''))],
1251
2135
        transport_path = 'sinhala'
1252
2136
        repo, client = self.setup_fake_client_and_repository(transport_path)
1253
2137
        client.add_success_response_with_body(encoded_body, 'ok')
1254
 
        result = self.applyDeprecated(one_four, repo.get_revision_graph, r2)
 
2138
        result = repo._get_revision_graph(r2)
1255
2139
        self.assertEqual(
1256
2140
            [('call_expecting_body', 'Repository.get_revision_graph',
1257
2141
             ('sinhala/', r2))],
1265
2149
        client.add_error_response('nosuchrevision', revid)
1266
2150
        # also check that the right revision is reported in the error
1267
2151
        self.assertRaises(errors.NoSuchRevision,
1268
 
            self.applyDeprecated, one_four, repo.get_revision_graph, revid)
 
2152
            repo._get_revision_graph, revid)
1269
2153
        self.assertEqual(
1270
2154
            [('call_expecting_body', 'Repository.get_revision_graph',
1271
2155
             ('sinhala/', revid))],
1277
2161
        repo, client = self.setup_fake_client_and_repository(transport_path)
1278
2162
        client.add_error_response('AnUnexpectedError')
1279
2163
        e = self.assertRaises(errors.UnknownErrorFromSmartServer,
1280
 
            self.applyDeprecated, one_four, repo.get_revision_graph, revid)
 
2164
            repo._get_revision_graph, revid)
1281
2165
        self.assertEqual(('AnUnexpectedError',), e.error_tuple)
1282
2166
 
1283
 
        
 
2167
 
 
2168
class TestRepositoryGetRevIdForRevno(TestRemoteRepository):
 
2169
 
 
2170
    def test_ok(self):
 
2171
        repo, client = self.setup_fake_client_and_repository('quack')
 
2172
        client.add_expected_call(
 
2173
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
 
2174
            'success', ('ok', 'rev-five'))
 
2175
        result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
 
2176
        self.assertEqual((True, 'rev-five'), result)
 
2177
        self.assertFinished(client)
 
2178
 
 
2179
    def test_history_incomplete(self):
 
2180
        repo, client = self.setup_fake_client_and_repository('quack')
 
2181
        client.add_expected_call(
 
2182
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
 
2183
            'success', ('history-incomplete', 10, 'rev-ten'))
 
2184
        result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
 
2185
        self.assertEqual((False, (10, 'rev-ten')), result)
 
2186
        self.assertFinished(client)
 
2187
 
 
2188
    def test_history_incomplete_with_fallback(self):
 
2189
        """A 'history-incomplete' response causes the fallback repository to be
 
2190
        queried too, if one is set.
 
2191
        """
 
2192
        # Make a repo with a fallback repo, both using a FakeClient.
 
2193
        format = remote.response_tuple_to_repo_format(
 
2194
            ('yes', 'no', 'yes', self.get_repo_format().network_name()))
 
2195
        repo, client = self.setup_fake_client_and_repository('quack')
 
2196
        repo._format = format
 
2197
        fallback_repo, ignored = self.setup_fake_client_and_repository(
 
2198
            'fallback')
 
2199
        fallback_repo._client = client
 
2200
        fallback_repo._format = format
 
2201
        repo.add_fallback_repository(fallback_repo)
 
2202
        # First the client should ask the primary repo
 
2203
        client.add_expected_call(
 
2204
            'Repository.get_rev_id_for_revno', ('quack/', 1, (42, 'rev-foo')),
 
2205
            'success', ('history-incomplete', 2, 'rev-two'))
 
2206
        # Then it should ask the fallback, using revno/revid from the
 
2207
        # history-incomplete response as the known revno/revid.
 
2208
        client.add_expected_call(
 
2209
            'Repository.get_rev_id_for_revno',('fallback/', 1, (2, 'rev-two')),
 
2210
            'success', ('ok', 'rev-one'))
 
2211
        result = repo.get_rev_id_for_revno(1, (42, 'rev-foo'))
 
2212
        self.assertEqual((True, 'rev-one'), result)
 
2213
        self.assertFinished(client)
 
2214
 
 
2215
    def test_nosuchrevision(self):
 
2216
        # 'nosuchrevision' is returned when the known-revid is not found in the
 
2217
        # remote repo.  The client translates that response to NoSuchRevision.
 
2218
        repo, client = self.setup_fake_client_and_repository('quack')
 
2219
        client.add_expected_call(
 
2220
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
 
2221
            'error', ('nosuchrevision', 'rev-foo'))
 
2222
        self.assertRaises(
 
2223
            errors.NoSuchRevision,
 
2224
            repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
 
2225
        self.assertFinished(client)
 
2226
 
 
2227
    def test_branch_fallback_locking(self):
 
2228
        """RemoteBranch.get_rev_id takes a read lock, and tries to call the
 
2229
        get_rev_id_for_revno verb.  If the verb is unknown the VFS fallback
 
2230
        will be invoked, which will fail if the repo is unlocked.
 
2231
        """
 
2232
        self.setup_smart_server_with_call_log()
 
2233
        tree = self.make_branch_and_memory_tree('.')
 
2234
        tree.lock_write()
 
2235
        rev1 = tree.commit('First')
 
2236
        rev2 = tree.commit('Second')
 
2237
        tree.unlock()
 
2238
        branch = tree.branch
 
2239
        self.assertFalse(branch.is_locked())
 
2240
        self.reset_smart_call_log()
 
2241
        verb = 'Repository.get_rev_id_for_revno'
 
2242
        self.disable_verb(verb)
 
2243
        self.assertEqual(rev1, branch.get_rev_id(1))
 
2244
        self.assertLength(1, [call for call in self.hpss_calls if
 
2245
                              call.call.method == verb])
 
2246
 
 
2247
 
1284
2248
class TestRepositoryIsShared(TestRemoteRepository):
1285
2249
 
1286
2250
    def test_is_shared(self):
1337
2301
            client._calls)
1338
2302
 
1339
2303
 
 
2304
class TestRepositorySetMakeWorkingTrees(TestRemoteRepository):
 
2305
 
 
2306
    def test_backwards_compat(self):
 
2307
        self.setup_smart_server_with_call_log()
 
2308
        repo = self.make_repository('.')
 
2309
        self.reset_smart_call_log()
 
2310
        verb = 'Repository.set_make_working_trees'
 
2311
        self.disable_verb(verb)
 
2312
        repo.set_make_working_trees(True)
 
2313
        call_count = len([call for call in self.hpss_calls if
 
2314
            call.call.method == verb])
 
2315
        self.assertEqual(1, call_count)
 
2316
 
 
2317
    def test_current(self):
 
2318
        transport_path = 'quack'
 
2319
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2320
        client.add_expected_call(
 
2321
            'Repository.set_make_working_trees', ('quack/', 'True'),
 
2322
            'success', ('ok',))
 
2323
        client.add_expected_call(
 
2324
            'Repository.set_make_working_trees', ('quack/', 'False'),
 
2325
            'success', ('ok',))
 
2326
        repo.set_make_working_trees(True)
 
2327
        repo.set_make_working_trees(False)
 
2328
 
 
2329
 
1340
2330
class TestRepositoryUnlock(TestRemoteRepository):
1341
2331
 
1342
2332
    def test_unlock(self):
1375
2365
        self.assertEqual([], client._calls)
1376
2366
 
1377
2367
 
 
2368
class TestRepositoryInsertStreamBase(TestRemoteRepository):
 
2369
    """Base class for Repository.insert_stream and .insert_stream_1.19
 
2370
    tests.
 
2371
    """
 
2372
    
 
2373
    def checkInsertEmptyStream(self, repo, client):
 
2374
        """Insert an empty stream, checking the result.
 
2375
 
 
2376
        This checks that there are no resume_tokens or missing_keys, and that
 
2377
        the client is finished.
 
2378
        """
 
2379
        sink = repo._get_sink()
 
2380
        fmt = repository.RepositoryFormat.get_default_format()
 
2381
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2382
        self.assertEqual([], resume_tokens)
 
2383
        self.assertEqual(set(), missing_keys)
 
2384
        self.assertFinished(client)
 
2385
 
 
2386
 
 
2387
class TestRepositoryInsertStream(TestRepositoryInsertStreamBase):
 
2388
    """Tests for using Repository.insert_stream verb when the _1.19 variant is
 
2389
    not available.
 
2390
 
 
2391
    This test case is very similar to TestRepositoryInsertStream_1_19.
 
2392
    """
 
2393
 
 
2394
    def setUp(self):
 
2395
        TestRemoteRepository.setUp(self)
 
2396
        self.disable_verb('Repository.insert_stream_1.19')
 
2397
 
 
2398
    def test_unlocked_repo(self):
 
2399
        transport_path = 'quack'
 
2400
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2401
        client.add_expected_call(
 
2402
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2403
            'unknown', ('Repository.insert_stream_1.19',))
 
2404
        client.add_expected_call(
 
2405
            'Repository.insert_stream', ('quack/', ''),
 
2406
            'success', ('ok',))
 
2407
        client.add_expected_call(
 
2408
            'Repository.insert_stream', ('quack/', ''),
 
2409
            'success', ('ok',))
 
2410
        self.checkInsertEmptyStream(repo, client)
 
2411
 
 
2412
    def test_locked_repo_with_no_lock_token(self):
 
2413
        transport_path = 'quack'
 
2414
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2415
        client.add_expected_call(
 
2416
            'Repository.lock_write', ('quack/', ''),
 
2417
            'success', ('ok', ''))
 
2418
        client.add_expected_call(
 
2419
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2420
            'unknown', ('Repository.insert_stream_1.19',))
 
2421
        client.add_expected_call(
 
2422
            'Repository.insert_stream', ('quack/', ''),
 
2423
            'success', ('ok',))
 
2424
        client.add_expected_call(
 
2425
            'Repository.insert_stream', ('quack/', ''),
 
2426
            'success', ('ok',))
 
2427
        repo.lock_write()
 
2428
        self.checkInsertEmptyStream(repo, client)
 
2429
 
 
2430
    def test_locked_repo_with_lock_token(self):
 
2431
        transport_path = 'quack'
 
2432
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2433
        client.add_expected_call(
 
2434
            'Repository.lock_write', ('quack/', ''),
 
2435
            'success', ('ok', 'a token'))
 
2436
        client.add_expected_call(
 
2437
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
 
2438
            'unknown', ('Repository.insert_stream_1.19',))
 
2439
        client.add_expected_call(
 
2440
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
 
2441
            'success', ('ok',))
 
2442
        client.add_expected_call(
 
2443
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
 
2444
            'success', ('ok',))
 
2445
        repo.lock_write()
 
2446
        self.checkInsertEmptyStream(repo, client)
 
2447
 
 
2448
    def test_stream_with_inventory_deltas(self):
 
2449
        """'inventory-deltas' substreams cannot be sent to the
 
2450
        Repository.insert_stream verb, because not all servers that implement
 
2451
        that verb will accept them.  So when one is encountered the RemoteSink
 
2452
        immediately stops using that verb and falls back to VFS insert_stream.
 
2453
        """
 
2454
        transport_path = 'quack'
 
2455
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2456
        client.add_expected_call(
 
2457
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2458
            'unknown', ('Repository.insert_stream_1.19',))
 
2459
        client.add_expected_call(
 
2460
            'Repository.insert_stream', ('quack/', ''),
 
2461
            'success', ('ok',))
 
2462
        client.add_expected_call(
 
2463
            'Repository.insert_stream', ('quack/', ''),
 
2464
            'success', ('ok',))
 
2465
        # Create a fake real repository for insert_stream to fall back on, so
 
2466
        # that we can directly see the records the RemoteSink passes to the
 
2467
        # real sink.
 
2468
        class FakeRealSink:
 
2469
            def __init__(self):
 
2470
                self.records = []
 
2471
            def insert_stream(self, stream, src_format, resume_tokens):
 
2472
                for substream_kind, substream in stream:
 
2473
                    self.records.append(
 
2474
                        (substream_kind, [record.key for record in substream]))
 
2475
                return ['fake tokens'], ['fake missing keys']
 
2476
        fake_real_sink = FakeRealSink()
 
2477
        class FakeRealRepository:
 
2478
            def _get_sink(self):
 
2479
                return fake_real_sink
 
2480
            def is_in_write_group(self):
 
2481
                return False
 
2482
            def refresh_data(self):
 
2483
                return True
 
2484
        repo._real_repository = FakeRealRepository()
 
2485
        sink = repo._get_sink()
 
2486
        fmt = repository.RepositoryFormat.get_default_format()
 
2487
        stream = self.make_stream_with_inv_deltas(fmt)
 
2488
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
 
2489
        # Every record from the first inventory delta should have been sent to
 
2490
        # the VFS sink.
 
2491
        expected_records = [
 
2492
            ('inventory-deltas', [('rev2',), ('rev3',)]),
 
2493
            ('texts', [('some-rev', 'some-file')])]
 
2494
        self.assertEqual(expected_records, fake_real_sink.records)
 
2495
        # The return values from the real sink's insert_stream are propagated
 
2496
        # back to the original caller.
 
2497
        self.assertEqual(['fake tokens'], resume_tokens)
 
2498
        self.assertEqual(['fake missing keys'], missing_keys)
 
2499
        self.assertFinished(client)
 
2500
 
 
2501
    def make_stream_with_inv_deltas(self, fmt):
 
2502
        """Make a simple stream with an inventory delta followed by more
 
2503
        records and more substreams to test that all records and substreams
 
2504
        from that point on are used.
 
2505
 
 
2506
        This sends, in order:
 
2507
           * inventories substream: rev1, rev2, rev3.  rev2 and rev3 are
 
2508
             inventory-deltas.
 
2509
           * texts substream: (some-rev, some-file)
 
2510
        """
 
2511
        # Define a stream using generators so that it isn't rewindable.
 
2512
        inv = inventory.Inventory(revision_id='rev1')
 
2513
        inv.root.revision = 'rev1'
 
2514
        def stream_with_inv_delta():
 
2515
            yield ('inventories', inventories_substream())
 
2516
            yield ('inventory-deltas', inventory_delta_substream())
 
2517
            yield ('texts', [
 
2518
                versionedfile.FulltextContentFactory(
 
2519
                    ('some-rev', 'some-file'), (), None, 'content')])
 
2520
        def inventories_substream():
 
2521
            # An empty inventory fulltext.  This will be streamed normally.
 
2522
            text = fmt._serializer.write_inventory_to_string(inv)
 
2523
            yield versionedfile.FulltextContentFactory(
 
2524
                ('rev1',), (), None, text)
 
2525
        def inventory_delta_substream():
 
2526
            # An inventory delta.  This can't be streamed via this verb, so it
 
2527
            # will trigger a fallback to VFS insert_stream.
 
2528
            entry = inv.make_entry(
 
2529
                'directory', 'newdir', inv.root.file_id, 'newdir-id')
 
2530
            entry.revision = 'ghost'
 
2531
            delta = [(None, 'newdir', 'newdir-id', entry)]
 
2532
            serializer = inventory_delta.InventoryDeltaSerializer(
 
2533
                versioned_root=True, tree_references=False)
 
2534
            lines = serializer.delta_to_lines('rev1', 'rev2', delta)
 
2535
            yield versionedfile.ChunkedContentFactory(
 
2536
                ('rev2',), (('rev1',)), None, lines)
 
2537
            # Another delta.
 
2538
            lines = serializer.delta_to_lines('rev1', 'rev3', delta)
 
2539
            yield versionedfile.ChunkedContentFactory(
 
2540
                ('rev3',), (('rev1',)), None, lines)
 
2541
        return stream_with_inv_delta()
 
2542
 
 
2543
 
 
2544
class TestRepositoryInsertStream_1_19(TestRepositoryInsertStreamBase):
 
2545
 
 
2546
    def test_unlocked_repo(self):
 
2547
        transport_path = 'quack'
 
2548
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2549
        client.add_expected_call(
 
2550
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2551
            'success', ('ok',))
 
2552
        client.add_expected_call(
 
2553
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2554
            'success', ('ok',))
 
2555
        self.checkInsertEmptyStream(repo, client)
 
2556
 
 
2557
    def test_locked_repo_with_no_lock_token(self):
 
2558
        transport_path = 'quack'
 
2559
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2560
        client.add_expected_call(
 
2561
            'Repository.lock_write', ('quack/', ''),
 
2562
            'success', ('ok', ''))
 
2563
        client.add_expected_call(
 
2564
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2565
            'success', ('ok',))
 
2566
        client.add_expected_call(
 
2567
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2568
            'success', ('ok',))
 
2569
        repo.lock_write()
 
2570
        self.checkInsertEmptyStream(repo, client)
 
2571
 
 
2572
    def test_locked_repo_with_lock_token(self):
 
2573
        transport_path = 'quack'
 
2574
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2575
        client.add_expected_call(
 
2576
            'Repository.lock_write', ('quack/', ''),
 
2577
            'success', ('ok', 'a token'))
 
2578
        client.add_expected_call(
 
2579
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
 
2580
            'success', ('ok',))
 
2581
        client.add_expected_call(
 
2582
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
 
2583
            'success', ('ok',))
 
2584
        repo.lock_write()
 
2585
        self.checkInsertEmptyStream(repo, client)
 
2586
 
 
2587
 
1378
2588
class TestRepositoryTarball(TestRemoteRepository):
1379
2589
 
1380
2590
    # This is a canned tarball reponse we can validate against
1414
2624
    """RemoteRepository.copy_content_into optimizations"""
1415
2625
 
1416
2626
    def test_copy_content_remote_to_local(self):
1417
 
        self.transport_server = server.SmartTCPServer_for_testing
 
2627
        self.transport_server = test_server.SmartTCPServer_for_testing
1418
2628
        src_repo = self.make_repository('repo1')
1419
2629
        src_repo = repository.Repository.open(self.get_url('repo1'))
1420
2630
        # At the moment the tarball-based copy_content_into can't write back
1429
2639
        src_repo.copy_content_into(dest_repo)
1430
2640
 
1431
2641
 
 
2642
class _StubRealPackRepository(object):
 
2643
 
 
2644
    def __init__(self, calls):
 
2645
        self.calls = calls
 
2646
        self._pack_collection = _StubPackCollection(calls)
 
2647
 
 
2648
    def is_in_write_group(self):
 
2649
        return False
 
2650
 
 
2651
    def refresh_data(self):
 
2652
        self.calls.append(('pack collection reload_pack_names',))
 
2653
 
 
2654
 
 
2655
class _StubPackCollection(object):
 
2656
 
 
2657
    def __init__(self, calls):
 
2658
        self.calls = calls
 
2659
 
 
2660
    def autopack(self):
 
2661
        self.calls.append(('pack collection autopack',))
 
2662
 
 
2663
 
 
2664
class TestRemotePackRepositoryAutoPack(TestRemoteRepository):
 
2665
    """Tests for RemoteRepository.autopack implementation."""
 
2666
 
 
2667
    def test_ok(self):
 
2668
        """When the server returns 'ok' and there's no _real_repository, then
 
2669
        nothing else happens: the autopack method is done.
 
2670
        """
 
2671
        transport_path = 'quack'
 
2672
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2673
        client.add_expected_call(
 
2674
            'PackRepository.autopack', ('quack/',), 'success', ('ok',))
 
2675
        repo.autopack()
 
2676
        self.assertFinished(client)
 
2677
 
 
2678
    def test_ok_with_real_repo(self):
 
2679
        """When the server returns 'ok' and there is a _real_repository, then
 
2680
        the _real_repository's reload_pack_name's method will be called.
 
2681
        """
 
2682
        transport_path = 'quack'
 
2683
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2684
        client.add_expected_call(
 
2685
            'PackRepository.autopack', ('quack/',),
 
2686
            'success', ('ok',))
 
2687
        repo._real_repository = _StubRealPackRepository(client._calls)
 
2688
        repo.autopack()
 
2689
        self.assertEqual(
 
2690
            [('call', 'PackRepository.autopack', ('quack/',)),
 
2691
             ('pack collection reload_pack_names',)],
 
2692
            client._calls)
 
2693
 
 
2694
    def test_backwards_compatibility(self):
 
2695
        """If the server does not recognise the PackRepository.autopack verb,
 
2696
        fallback to the real_repository's implementation.
 
2697
        """
 
2698
        transport_path = 'quack'
 
2699
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2700
        client.add_unknown_method_response('PackRepository.autopack')
 
2701
        def stub_ensure_real():
 
2702
            client._calls.append(('_ensure_real',))
 
2703
            repo._real_repository = _StubRealPackRepository(client._calls)
 
2704
        repo._ensure_real = stub_ensure_real
 
2705
        repo.autopack()
 
2706
        self.assertEqual(
 
2707
            [('call', 'PackRepository.autopack', ('quack/',)),
 
2708
             ('_ensure_real',),
 
2709
             ('pack collection autopack',)],
 
2710
            client._calls)
 
2711
 
 
2712
 
1432
2713
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
1433
2714
    """Base class for unit tests for bzrlib.remote._translate_error."""
1434
2715
 
1462
2743
                **context)
1463
2744
        return translated_error
1464
2745
 
1465
 
    
 
2746
 
1466
2747
class TestErrorTranslationSuccess(TestErrorTranslationBase):
1467
2748
    """Unit tests for bzrlib.remote._translate_error.
1468
 
    
 
2749
 
1469
2750
    Given an ErrorFromSmartServer (which has an error tuple from a smart
1470
2751
    server) and some context, _translate_error raises more specific errors from
1471
2752
    bzrlib.errors.
1497
2778
        expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
1498
2779
        self.assertEqual(expected_error, translated_error)
1499
2780
 
 
2781
    def test_nobranch_one_arg(self):
 
2782
        bzrdir = self.make_bzrdir('')
 
2783
        translated_error = self.translateTuple(
 
2784
            ('nobranch', 'extra detail'), bzrdir=bzrdir)
 
2785
        expected_error = errors.NotBranchError(
 
2786
            path=bzrdir.root_transport.base,
 
2787
            detail='extra detail')
 
2788
        self.assertEqual(expected_error, translated_error)
 
2789
 
1500
2790
    def test_LockContention(self):
1501
2791
        translated_error = self.translateTuple(('LockContention',))
1502
2792
        expected_error = errors.LockContention('(remote lock)')
1530
2820
        expected_error = errors.DivergedBranches(branch, other_branch)
1531
2821
        self.assertEqual(expected_error, translated_error)
1532
2822
 
 
2823
    def test_ReadError_no_args(self):
 
2824
        path = 'a path'
 
2825
        translated_error = self.translateTuple(('ReadError',), path=path)
 
2826
        expected_error = errors.ReadError(path)
 
2827
        self.assertEqual(expected_error, translated_error)
 
2828
 
 
2829
    def test_ReadError(self):
 
2830
        path = 'a path'
 
2831
        translated_error = self.translateTuple(('ReadError', path))
 
2832
        expected_error = errors.ReadError(path)
 
2833
        self.assertEqual(expected_error, translated_error)
 
2834
 
 
2835
    def test_IncompatibleRepositories(self):
 
2836
        translated_error = self.translateTuple(('IncompatibleRepositories',
 
2837
            "repo1", "repo2", "details here"))
 
2838
        expected_error = errors.IncompatibleRepositories("repo1", "repo2",
 
2839
            "details here")
 
2840
        self.assertEqual(expected_error, translated_error)
 
2841
 
 
2842
    def test_PermissionDenied_no_args(self):
 
2843
        path = 'a path'
 
2844
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
 
2845
        expected_error = errors.PermissionDenied(path)
 
2846
        self.assertEqual(expected_error, translated_error)
 
2847
 
 
2848
    def test_PermissionDenied_one_arg(self):
 
2849
        path = 'a path'
 
2850
        translated_error = self.translateTuple(('PermissionDenied', path))
 
2851
        expected_error = errors.PermissionDenied(path)
 
2852
        self.assertEqual(expected_error, translated_error)
 
2853
 
 
2854
    def test_PermissionDenied_one_arg_and_context(self):
 
2855
        """Given a choice between a path from the local context and a path on
 
2856
        the wire, _translate_error prefers the path from the local context.
 
2857
        """
 
2858
        local_path = 'local path'
 
2859
        remote_path = 'remote path'
 
2860
        translated_error = self.translateTuple(
 
2861
            ('PermissionDenied', remote_path), path=local_path)
 
2862
        expected_error = errors.PermissionDenied(local_path)
 
2863
        self.assertEqual(expected_error, translated_error)
 
2864
 
 
2865
    def test_PermissionDenied_two_args(self):
 
2866
        path = 'a path'
 
2867
        extra = 'a string with extra info'
 
2868
        translated_error = self.translateTuple(
 
2869
            ('PermissionDenied', path, extra))
 
2870
        expected_error = errors.PermissionDenied(path, extra)
 
2871
        self.assertEqual(expected_error, translated_error)
 
2872
 
1533
2873
 
1534
2874
class TestErrorTranslationRobustness(TestErrorTranslationBase):
1535
2875
    """Unit tests for bzrlib.remote._translate_error's robustness.
1536
 
    
 
2876
 
1537
2877
    TestErrorTranslationSuccess is for cases where _translate_error can
1538
2878
    translate successfully.  This class about how _translate_err behaves when
1539
2879
    it fails to translate: it re-raises the original error.
1565
2905
        # In addition to re-raising ErrorFromSmartServer, some debug info has
1566
2906
        # been muttered to the log file for developer to look at.
1567
2907
        self.assertContainsRe(
1568
 
            self._get_log(keep_log_file=True),
 
2908
            self.get_log(),
1569
2909
            "Missing key 'branch' in context")
1570
 
        
 
2910
 
 
2911
    def test_path_missing(self):
 
2912
        """Some translations (PermissionDenied, ReadError) can determine the
 
2913
        'path' variable from either the wire or the local context.  If neither
 
2914
        has it, then an error is raised.
 
2915
        """
 
2916
        error_tuple = ('ReadError',)
 
2917
        server_error = errors.ErrorFromSmartServer(error_tuple)
 
2918
        translated_error = self.translateErrorFromSmartServer(server_error)
 
2919
        self.assertEqual(server_error, translated_error)
 
2920
        # In addition to re-raising ErrorFromSmartServer, some debug info has
 
2921
        # been muttered to the log file for developer to look at.
 
2922
        self.assertContainsRe(self.get_log(), "Missing key 'path' in context")
 
2923
 
1571
2924
 
1572
2925
class TestStacking(tests.TestCaseWithTransport):
1573
2926
    """Tests for operations on stacked remote repositories.
1574
 
    
 
2927
 
1575
2928
    The underlying format type must support stacking.
1576
2929
    """
1577
2930
 
1581
2934
        # revision, then open it over hpss - we should be able to see that
1582
2935
        # revision.
1583
2936
        base_transport = self.get_transport()
1584
 
        base_builder = self.make_branch_builder('base', format='1.6')
 
2937
        base_builder = self.make_branch_builder('base', format='1.9')
1585
2938
        base_builder.start_series()
1586
2939
        base_revid = base_builder.build_snapshot('rev-id', None,
1587
2940
            [('add', ('', None, 'directory', None))],
1588
2941
            'message')
1589
2942
        base_builder.finish_series()
1590
 
        stacked_branch = self.make_branch('stacked', format='1.6')
 
2943
        stacked_branch = self.make_branch('stacked', format='1.9')
1591
2944
        stacked_branch.set_stacked_on_url('../base')
1592
2945
        # start a server looking at this
1593
 
        smart_server = server.SmartTCPServer_for_testing()
1594
 
        smart_server.setUp()
1595
 
        self.addCleanup(smart_server.tearDown)
 
2946
        smart_server = test_server.SmartTCPServer_for_testing()
 
2947
        self.start_server(smart_server)
1596
2948
        remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
1597
2949
        # can get its branch and repository
1598
2950
        remote_branch = remote_bzrdir.open_branch()
1601
2953
        try:
1602
2954
            # it should have an appropriate fallback repository, which should also
1603
2955
            # be a RemoteRepository
1604
 
            self.assertEquals(len(remote_repo._fallback_repositories), 1)
 
2956
            self.assertLength(1, remote_repo._fallback_repositories)
1605
2957
            self.assertIsInstance(remote_repo._fallback_repositories[0],
1606
2958
                RemoteRepository)
1607
2959
            # and it has the revision committed to the underlying repository;
1612
2964
                'message')
1613
2965
        finally:
1614
2966
            remote_repo.unlock()
 
2967
 
 
2968
    def prepare_stacked_remote_branch(self):
 
2969
        """Get stacked_upon and stacked branches with content in each."""
 
2970
        self.setup_smart_server_with_call_log()
 
2971
        tree1 = self.make_branch_and_tree('tree1', format='1.9')
 
2972
        tree1.commit('rev1', rev_id='rev1')
 
2973
        tree2 = tree1.branch.bzrdir.sprout('tree2', stacked=True
 
2974
            ).open_workingtree()
 
2975
        local_tree = tree2.branch.create_checkout('local')
 
2976
        local_tree.commit('local changes make me feel good.')
 
2977
        branch2 = Branch.open(self.get_url('tree2'))
 
2978
        branch2.lock_read()
 
2979
        self.addCleanup(branch2.unlock)
 
2980
        return tree1.branch, branch2
 
2981
 
 
2982
    def test_stacked_get_parent_map(self):
 
2983
        # the public implementation of get_parent_map obeys stacking
 
2984
        _, branch = self.prepare_stacked_remote_branch()
 
2985
        repo = branch.repository
 
2986
        self.assertEqual(['rev1'], repo.get_parent_map(['rev1']).keys())
 
2987
 
 
2988
    def test_unstacked_get_parent_map(self):
 
2989
        # _unstacked_provider.get_parent_map ignores stacking
 
2990
        _, branch = self.prepare_stacked_remote_branch()
 
2991
        provider = branch.repository._unstacked_provider
 
2992
        self.assertEqual([], provider.get_parent_map(['rev1']).keys())
 
2993
 
 
2994
    def fetch_stream_to_rev_order(self, stream):
 
2995
        result = []
 
2996
        for kind, substream in stream:
 
2997
            if not kind == 'revisions':
 
2998
                list(substream)
 
2999
            else:
 
3000
                for content in substream:
 
3001
                    result.append(content.key[-1])
 
3002
        return result
 
3003
 
 
3004
    def get_ordered_revs(self, format, order, branch_factory=None):
 
3005
        """Get a list of the revisions in a stream to format format.
 
3006
 
 
3007
        :param format: The format of the target.
 
3008
        :param order: the order that target should have requested.
 
3009
        :param branch_factory: A callable to create a trunk and stacked branch
 
3010
            to fetch from. If none, self.prepare_stacked_remote_branch is used.
 
3011
        :result: The revision ids in the stream, in the order seen,
 
3012
            the topological order of revisions in the source.
 
3013
        """
 
3014
        unordered_format = bzrdir.format_registry.get(format)()
 
3015
        target_repository_format = unordered_format.repository_format
 
3016
        # Cross check
 
3017
        self.assertEqual(order, target_repository_format._fetch_order)
 
3018
        if branch_factory is None:
 
3019
            branch_factory = self.prepare_stacked_remote_branch
 
3020
        _, stacked = branch_factory()
 
3021
        source = stacked.repository._get_source(target_repository_format)
 
3022
        tip = stacked.last_revision()
 
3023
        revs = stacked.repository.get_ancestry(tip)
 
3024
        search = graph.PendingAncestryResult([tip], stacked.repository)
 
3025
        self.reset_smart_call_log()
 
3026
        stream = source.get_stream(search)
 
3027
        if None in revs:
 
3028
            revs.remove(None)
 
3029
        # We trust that if a revision is in the stream the rest of the new
 
3030
        # content for it is too, as per our main fetch tests; here we are
 
3031
        # checking that the revisions are actually included at all, and their
 
3032
        # order.
 
3033
        return self.fetch_stream_to_rev_order(stream), revs
 
3034
 
 
3035
    def test_stacked_get_stream_unordered(self):
 
3036
        # Repository._get_source.get_stream() from a stacked repository with
 
3037
        # unordered yields the full data from both stacked and stacked upon
 
3038
        # sources.
 
3039
        rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered')
 
3040
        self.assertEqual(set(expected_revs), set(rev_ord))
 
3041
        # Getting unordered results should have made a streaming data request
 
3042
        # from the server, then one from the backing branch.
 
3043
        self.assertLength(2, self.hpss_calls)
 
3044
 
 
3045
    def test_stacked_on_stacked_get_stream_unordered(self):
 
3046
        # Repository._get_source.get_stream() from a stacked repository which
 
3047
        # is itself stacked yields the full data from all three sources.
 
3048
        def make_stacked_stacked():
 
3049
            _, stacked = self.prepare_stacked_remote_branch()
 
3050
            tree = stacked.bzrdir.sprout('tree3', stacked=True
 
3051
                ).open_workingtree()
 
3052
            local_tree = tree.branch.create_checkout('local-tree3')
 
3053
            local_tree.commit('more local changes are better')
 
3054
            branch = Branch.open(self.get_url('tree3'))
 
3055
            branch.lock_read()
 
3056
            self.addCleanup(branch.unlock)
 
3057
            return None, branch
 
3058
        rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
 
3059
            branch_factory=make_stacked_stacked)
 
3060
        self.assertEqual(set(expected_revs), set(rev_ord))
 
3061
        # Getting unordered results should have made a streaming data request
 
3062
        # from the server, and one from each backing repo
 
3063
        self.assertLength(3, self.hpss_calls)
 
3064
 
 
3065
    def test_stacked_get_stream_topological(self):
 
3066
        # Repository._get_source.get_stream() from a stacked repository with
 
3067
        # topological sorting yields the full data from both stacked and
 
3068
        # stacked upon sources in topological order.
 
3069
        rev_ord, expected_revs = self.get_ordered_revs('knit', 'topological')
 
3070
        self.assertEqual(expected_revs, rev_ord)
 
3071
        # Getting topological sort requires VFS calls still - one of which is
 
3072
        # pushing up from the bound branch.
 
3073
        self.assertLength(13, self.hpss_calls)
 
3074
 
 
3075
    def test_stacked_get_stream_groupcompress(self):
 
3076
        # Repository._get_source.get_stream() from a stacked repository with
 
3077
        # groupcompress sorting yields the full data from both stacked and
 
3078
        # stacked upon sources in groupcompress order.
 
3079
        raise tests.TestSkipped('No groupcompress ordered format available')
 
3080
        rev_ord, expected_revs = self.get_ordered_revs('dev5', 'groupcompress')
 
3081
        self.assertEqual(expected_revs, reversed(rev_ord))
 
3082
        # Getting unordered results should have made a streaming data request
 
3083
        # from the backing branch, and one from the stacked on branch.
 
3084
        self.assertLength(2, self.hpss_calls)
 
3085
 
 
3086
    def test_stacked_pull_more_than_stacking_has_bug_360791(self):
 
3087
        # When pulling some fixed amount of content that is more than the
 
3088
        # source has (because some is coming from a fallback branch, no error
 
3089
        # should be received. This was reported as bug 360791.
 
3090
        # Need three branches: a trunk, a stacked branch, and a preexisting
 
3091
        # branch pulling content from stacked and trunk.
 
3092
        self.setup_smart_server_with_call_log()
 
3093
        trunk = self.make_branch_and_tree('trunk', format="1.9-rich-root")
 
3094
        r1 = trunk.commit('start')
 
3095
        stacked_branch = trunk.branch.create_clone_on_transport(
 
3096
            self.get_transport('stacked'), stacked_on=trunk.branch.base)
 
3097
        local = self.make_branch('local', format='1.9-rich-root')
 
3098
        local.repository.fetch(stacked_branch.repository,
 
3099
            stacked_branch.last_revision())
 
3100
 
 
3101
 
 
3102
class TestRemoteBranchEffort(tests.TestCaseWithTransport):
 
3103
 
 
3104
    def setUp(self):
 
3105
        super(TestRemoteBranchEffort, self).setUp()
 
3106
        # Create a smart server that publishes whatever the backing VFS server
 
3107
        # does.
 
3108
        self.smart_server = test_server.SmartTCPServer_for_testing()
 
3109
        self.start_server(self.smart_server, self.get_server())
 
3110
        # Log all HPSS calls into self.hpss_calls.
 
3111
        _SmartClient.hooks.install_named_hook(
 
3112
            'call', self.capture_hpss_call, None)
 
3113
        self.hpss_calls = []
 
3114
 
 
3115
    def capture_hpss_call(self, params):
 
3116
        self.hpss_calls.append(params.method)
 
3117
 
 
3118
    def test_copy_content_into_avoids_revision_history(self):
 
3119
        local = self.make_branch('local')
 
3120
        remote_backing_tree = self.make_branch_and_tree('remote')
 
3121
        remote_backing_tree.commit("Commit.")
 
3122
        remote_branch_url = self.smart_server.get_url() + 'remote'
 
3123
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
 
3124
        local.repository.fetch(remote_branch.repository)
 
3125
        self.hpss_calls = []
 
3126
        remote_branch.copy_content_into(local)
 
3127
        self.assertFalse('Branch.revision_history' in self.hpss_calls)