205
132
class FakeClient(_SmartClient):
206
133
"""Lookalike for _SmartClient allowing testing."""
135
def __init__(self, responses, fake_medium_base='fake base'):
136
"""Create a FakeClient.
208
def __init__(self, fake_medium_base='fake base'):
209
"""Create a FakeClient."""
138
:param responses: A list of response-tuple, body-data pairs to be sent
141
self.responses = responses
212
143
self.expecting_body = False
213
# if non-None, this is the list of expected calls, with only the
214
# method name and arguments included. the body might be hard to
215
# compute so is not included. If a call is None, that call can
217
self._expected_calls = None
218
_SmartClient.__init__(self, FakeMedium(self._calls, fake_medium_base))
220
def add_expected_call(self, call_name, call_args, response_type,
221
response_args, response_body=None):
222
if self._expected_calls is None:
223
self._expected_calls = []
224
self._expected_calls.append((call_name, call_args))
225
self.responses.append((response_type, response_args, response_body))
227
def add_success_response(self, *args):
228
self.responses.append(('success', args, None))
230
def add_success_response_with_body(self, body, *args):
231
self.responses.append(('success', args, body))
232
if self._expected_calls is not None:
233
self._expected_calls.append(None)
235
def add_error_response(self, *args):
236
self.responses.append(('error', args))
238
def add_unknown_method_response(self, verb):
239
self.responses.append(('unknown', verb))
241
def finished_test(self):
242
if self._expected_calls:
243
raise AssertionError("%r finished but was still expecting %r"
244
% (self, self._expected_calls[0]))
246
def _get_next_response(self):
248
response_tuple = self.responses.pop(0)
249
except IndexError, e:
250
raise AssertionError("%r didn't expect any more calls"
252
if response_tuple[0] == 'unknown':
253
raise errors.UnknownSmartMethod(response_tuple[1])
254
elif response_tuple[0] == 'error':
255
raise errors.ErrorFromSmartServer(response_tuple[1])
256
return response_tuple
258
def _check_call(self, method, args):
259
if self._expected_calls is None:
260
# the test should be updated to say what it expects
263
next_call = self._expected_calls.pop(0)
265
raise AssertionError("%r didn't expect any more calls "
267
% (self, method, args,))
268
if next_call is None:
270
if method != next_call[0] or args != next_call[1]:
271
raise AssertionError("%r expected %r%r "
273
% (self, next_call[0], next_call[1], method, args,))
144
_SmartClient.__init__(self, FakeMedium(self._calls), fake_medium_base)
275
146
def call(self, method, *args):
276
self._check_call(method, args)
277
147
self._calls.append(('call', method, args))
278
return self._get_next_response()[1]
148
return self.responses.pop(0)[0]
280
150
def call_expecting_body(self, method, *args):
281
self._check_call(method, args)
282
151
self._calls.append(('call_expecting_body', method, args))
283
result = self._get_next_response()
152
result = self.responses.pop(0)
284
153
self.expecting_body = True
285
return result[1], FakeProtocol(result[2], self)
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)
154
return result[0], FakeProtocol(result[1], self)
293
156
def call_with_body_bytes_expecting_body(self, method, args, body):
294
self._check_call(method, args)
295
157
self._calls.append(('call_with_body_bytes_expecting_body', method,
297
result = self._get_next_response()
159
result = self.responses.pop(0)
298
160
self.expecting_body = True
299
return result[1], FakeProtocol(result[2], self)
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
314
class FakeMedium(medium.SmartClientMedium):
316
def __init__(self, client_calls, base):
317
medium.SmartClientMedium.__init__(self, base)
161
return result[0], FakeProtocol(result[1], self)
164
class FakeMedium(object):
166
def __init__(self, client_calls):
167
self._remote_is_at_least_1_2 = True
318
168
self._client_calls = client_calls
320
170
def disconnect(self):
335
184
self.assertTrue(result)
338
class TestRemote(tests.TestCaseWithMemoryTransport):
340
def get_branch_format(self):
341
reference_bzrdir_format = bzrdir.format_registry.get('default')()
342
return reference_bzrdir_format.get_branch_format()
344
def get_repo_format(self):
345
reference_bzrdir_format = bzrdir.format_registry.get('default')()
346
return reference_bzrdir_format.repository_format
348
def assertFinished(self, fake_client):
349
"""Assert that all of a FakeClient's expected calls have occurred."""
350
fake_client.finished_test()
353
class Test_ClientMedium_remote_path_from_transport(tests.TestCase):
354
"""Tests for the behaviour of client_medium.remote_path_from_transport."""
187
class Test_SmartClient_remote_path_from_transport(tests.TestCase):
188
"""Tests for the behaviour of _SmartClient.remote_path_from_transport."""
356
190
def assertRemotePath(self, expected, client_base, transport_base):
357
"""Assert that the result of
358
SmartClientMedium.remote_path_from_transport is the expected value for
359
a given client_base and transport_base.
191
"""Assert that the result of _SmartClient.remote_path_from_transport
192
is the expected value for a given client_base and transport_base.
361
client_medium = medium.SmartClientMedium(client_base)
194
dummy_medium = 'dummy medium'
195
client = _SmartClient(dummy_medium, client_base)
362
196
transport = get_transport(transport_base)
363
result = client_medium.remote_path_from_transport(transport)
197
result = client.remote_path_from_transport(transport)
364
198
self.assertEqual(expected, result)
366
200
def test_remote_path_from_transport(self):
367
"""SmartClientMedium.remote_path_from_transport calculates a URL for
368
the given transport relative to the root of the client base URL.
201
"""_SmartClient.remote_path_from_transport calculates a URL for the
202
given transport relative to the root of the client base URL.
370
204
self.assertRemotePath('xyz/', 'bzr://host/path', 'bzr://host/xyz')
371
205
self.assertRemotePath(
372
206
'path/xyz/', 'bzr://host/path', 'bzr://host/path/xyz')
374
def assertRemotePathHTTP(self, expected, transport_base, relpath):
375
"""Assert that the result of
376
HttpTransportBase.remote_path_from_transport is the expected value for
377
a given transport_base and relpath of that transport. (Note that
378
HttpTransportBase is a subclass of SmartClientMedium)
380
base_transport = get_transport(transport_base)
381
client_medium = base_transport.get_smart_medium()
382
cloned_transport = base_transport.clone(relpath)
383
result = client_medium.remote_path_from_transport(cloned_transport)
384
self.assertEqual(expected, result)
386
208
def test_remote_path_from_transport_http(self):
387
209
"""Remote paths for HTTP transports are calculated differently to other
388
210
transports. They are just relative to the client base, not the root
389
211
directory of the host.
391
213
for scheme in ['http:', 'https:', 'bzr+http:', 'bzr+https:']:
392
self.assertRemotePathHTTP(
393
'../xyz/', scheme + '//host/path', '../xyz/')
394
self.assertRemotePathHTTP(
395
'xyz/', scheme + '//host/path', 'xyz/')
398
class Test_ClientMedium_remote_is_at_least(tests.TestCase):
399
"""Tests for the behaviour of client_medium.remote_is_at_least."""
401
def test_initially_unlimited(self):
402
"""A fresh medium assumes that the remote side supports all
405
client_medium = medium.SmartClientMedium('dummy base')
406
self.assertFalse(client_medium._is_remote_before((99, 99)))
408
def test__remember_remote_is_before(self):
409
"""Calling _remember_remote_is_before ratchets down the known remote
412
client_medium = medium.SmartClientMedium('dummy base')
413
# Mark the remote side as being less than 1.6. The remote side may
415
client_medium._remember_remote_is_before((1, 6))
416
self.assertTrue(client_medium._is_remote_before((1, 6)))
417
self.assertFalse(client_medium._is_remote_before((1, 5)))
418
# Calling _remember_remote_is_before again with a lower value works.
419
client_medium._remember_remote_is_before((1, 5))
420
self.assertTrue(client_medium._is_remote_before((1, 5)))
421
# If you call _remember_remote_is_before with a higher value it logs a
422
# warning, and continues to remember the lower value.
423
self.assertNotContainsRe(self.get_log(), '_remember_remote_is_before')
424
client_medium._remember_remote_is_before((1, 9))
425
self.assertContainsRe(self.get_log(), '_remember_remote_is_before')
426
self.assertTrue(client_medium._is_remote_before((1, 5)))
429
class TestBzrDirCloningMetaDir(TestRemote):
431
def test_backwards_compat(self):
432
self.setup_smart_server_with_call_log()
433
a_dir = self.make_bzrdir('.')
434
self.reset_smart_call_log()
435
verb = 'BzrDir.cloning_metadir'
436
self.disable_verb(verb)
437
format = a_dir.cloning_metadir()
438
call_count = len([call for call in self.hpss_calls if
439
call.call.method == verb])
440
self.assertEqual(1, call_count)
442
def test_branch_reference(self):
443
transport = self.get_transport('quack')
444
referenced = self.make_branch('referenced')
445
expected = referenced.bzrdir.cloning_metadir()
446
client = FakeClient(transport.base)
447
client.add_expected_call(
448
'BzrDir.cloning_metadir', ('quack/', 'False'),
449
'error', ('BranchReference',)),
450
client.add_expected_call(
451
'BzrDir.open_branchV3', ('quack/',),
452
'success', ('ref', self.get_url('referenced'))),
453
a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
455
result = a_bzrdir.cloning_metadir()
456
# We should have got a control dir matching the referenced branch.
457
self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
458
self.assertEqual(expected._repository_format, result._repository_format)
459
self.assertEqual(expected._branch_format, result._branch_format)
460
self.assertFinished(client)
462
def test_current_server(self):
463
transport = self.get_transport('.')
464
transport = transport.clone('quack')
465
self.make_bzrdir('quack')
466
client = FakeClient(transport.base)
467
reference_bzrdir_format = bzrdir.format_registry.get('default')()
468
control_name = reference_bzrdir_format.network_name()
469
client.add_expected_call(
470
'BzrDir.cloning_metadir', ('quack/', 'False'),
471
'success', (control_name, '', ('branch', ''))),
472
a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
474
result = a_bzrdir.cloning_metadir()
475
# We should have got a reference control dir with default branch and
476
# repository formats.
477
# This pokes a little, just to be sure.
478
self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
479
self.assertEqual(None, result._repository_format)
480
self.assertEqual(None, result._branch_format)
481
self.assertFinished(client)
484
class TestBzrDirOpen(TestRemote):
486
def make_fake_client_and_transport(self, path='quack'):
487
transport = MemoryTransport()
488
transport.mkdir(path)
489
transport = transport.clone(path)
490
client = FakeClient(transport.base)
491
return client, transport
493
def test_absent(self):
494
client, transport = self.make_fake_client_and_transport()
495
client.add_expected_call(
496
'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
497
self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
498
remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
499
self.assertFinished(client)
501
def test_present_without_workingtree(self):
502
client, transport = self.make_fake_client_and_transport()
503
client.add_expected_call(
504
'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
505
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
506
_client=client, _force_probe=True)
507
self.assertIsInstance(bd, RemoteBzrDir)
508
self.assertFalse(bd.has_workingtree())
509
self.assertRaises(errors.NoWorkingTree, bd.open_workingtree)
510
self.assertFinished(client)
512
def test_present_with_workingtree(self):
513
client, transport = self.make_fake_client_and_transport()
514
client.add_expected_call(
515
'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
516
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
517
_client=client, _force_probe=True)
518
self.assertIsInstance(bd, RemoteBzrDir)
519
self.assertTrue(bd.has_workingtree())
520
self.assertRaises(errors.NotLocalUrl, bd.open_workingtree)
521
self.assertFinished(client)
523
def test_backwards_compat(self):
524
client, transport = self.make_fake_client_and_transport()
525
client.add_expected_call(
526
'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
527
client.add_expected_call(
528
'BzrDir.open', ('quack/',), 'success', ('yes',))
529
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
530
_client=client, _force_probe=True)
531
self.assertIsInstance(bd, RemoteBzrDir)
532
self.assertFinished(client)
534
def test_backwards_compat_hpss_v2(self):
535
client, transport = self.make_fake_client_and_transport()
536
# Monkey-patch fake client to simulate real-world behaviour with v2
537
# server: upon first RPC call detect the protocol version, and because
538
# the version is 2 also do _remember_remote_is_before((1, 6)) before
539
# continuing with the RPC.
540
orig_check_call = client._check_call
541
def check_call(method, args):
542
client._medium._protocol_version = 2
543
client._medium._remember_remote_is_before((1, 6))
544
client._check_call = orig_check_call
545
client._check_call(method, args)
546
client._check_call = check_call
547
client.add_expected_call(
548
'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
549
client.add_expected_call(
550
'BzrDir.open', ('quack/',), 'success', ('yes',))
551
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
552
_client=client, _force_probe=True)
553
self.assertIsInstance(bd, RemoteBzrDir)
554
self.assertFinished(client)
557
class TestBzrDirOpenBranch(TestRemote):
559
def test_backwards_compat(self):
560
self.setup_smart_server_with_call_log()
561
self.make_branch('.')
562
a_dir = BzrDir.open(self.get_url('.'))
563
self.reset_smart_call_log()
564
verb = 'BzrDir.open_branchV3'
565
self.disable_verb(verb)
566
format = a_dir.open_branch()
567
call_count = len([call for call in self.hpss_calls if
568
call.call.method == verb])
569
self.assertEqual(1, call_count)
214
self.assertRemotePath(
215
'../xyz/', scheme + '//host/path', scheme + '//host/xyz')
216
self.assertRemotePath(
217
'xyz/', scheme + '//host/path', scheme + '//host/path/xyz')
220
class TestBzrDirOpenBranch(tests.TestCase):
571
222
def test_branch_present(self):
572
reference_format = self.get_repo_format()
573
network_name = reference_format.network_name()
574
branch_network_name = self.get_branch_format().network_name()
575
223
transport = MemoryTransport()
576
224
transport.mkdir('quack')
577
225
transport = transport.clone('quack')
578
client = FakeClient(transport.base)
579
client.add_expected_call(
580
'BzrDir.open_branchV3', ('quack/',),
581
'success', ('branch', branch_network_name))
582
client.add_expected_call(
583
'BzrDir.find_repositoryV3', ('quack/',),
584
'success', ('ok', '', 'no', 'no', 'no', network_name))
585
client.add_expected_call(
586
'Branch.get_stacked_on_url', ('quack/',),
587
'error', ('NotStacked',))
588
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
226
client = FakeClient([(('ok', ''), ), (('ok', '', 'no', 'no', 'no'), )],
228
bzrdir = RemoteBzrDir(transport, _client=client)
590
229
result = bzrdir.open_branch()
231
[('call', 'BzrDir.open_branch', ('quack/',)),
232
('call', 'BzrDir.find_repositoryV2', ('quack/',))],
591
234
self.assertIsInstance(result, RemoteBranch)
592
235
self.assertEqual(bzrdir, result.bzrdir)
593
self.assertFinished(client)
595
237
def test_branch_missing(self):
596
238
transport = MemoryTransport()
597
239
transport.mkdir('quack')
598
240
transport = transport.clone('quack')
599
client = FakeClient(transport.base)
600
client.add_error_response('nobranch')
601
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
241
client = FakeClient([(('nobranch',), )], transport.base)
242
bzrdir = RemoteBzrDir(transport, _client=client)
603
243
self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
604
244
self.assertEqual(
605
[('call', 'BzrDir.open_branchV3', ('quack/',))],
245
[('call', 'BzrDir.open_branch', ('quack/',))],
608
248
def test__get_tree_branch(self):
689
315
RemoteBzrDirFormat.probe_transport, OldServerTransport())
692
class TestBzrDirCreateBranch(TestRemote):
694
def test_backwards_compat(self):
695
self.setup_smart_server_with_call_log()
696
repo = self.make_repository('.')
697
self.reset_smart_call_log()
698
self.disable_verb('BzrDir.create_branch')
699
branch = repo.bzrdir.create_branch()
700
create_branch_call_count = len([call for call in self.hpss_calls if
701
call.call.method == 'BzrDir.create_branch'])
702
self.assertEqual(1, create_branch_call_count)
704
def test_current_server(self):
705
transport = self.get_transport('.')
706
transport = transport.clone('quack')
707
self.make_repository('quack')
708
client = FakeClient(transport.base)
709
reference_bzrdir_format = bzrdir.format_registry.get('default')()
710
reference_format = reference_bzrdir_format.get_branch_format()
711
network_name = reference_format.network_name()
712
reference_repo_fmt = reference_bzrdir_format.repository_format
713
reference_repo_name = reference_repo_fmt.network_name()
714
client.add_expected_call(
715
'BzrDir.create_branch', ('quack/', network_name),
716
'success', ('ok', network_name, '', 'no', 'no', 'yes',
717
reference_repo_name))
718
a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
720
branch = a_bzrdir.create_branch()
721
# We should have got a remote branch
722
self.assertIsInstance(branch, remote.RemoteBranch)
723
# its format should have the settings from the response
724
format = branch._format
725
self.assertEqual(network_name, format.network_name())
728
class TestBzrDirCreateRepository(TestRemote):
730
def test_backwards_compat(self):
731
self.setup_smart_server_with_call_log()
732
bzrdir = self.make_bzrdir('.')
733
self.reset_smart_call_log()
734
self.disable_verb('BzrDir.create_repository')
735
repo = bzrdir.create_repository()
736
create_repo_call_count = len([call for call in self.hpss_calls if
737
call.call.method == 'BzrDir.create_repository'])
738
self.assertEqual(1, create_repo_call_count)
740
def test_current_server(self):
741
transport = self.get_transport('.')
742
transport = transport.clone('quack')
743
self.make_bzrdir('quack')
744
client = FakeClient(transport.base)
745
reference_bzrdir_format = bzrdir.format_registry.get('default')()
746
reference_format = reference_bzrdir_format.repository_format
747
network_name = reference_format.network_name()
748
client.add_expected_call(
749
'BzrDir.create_repository', ('quack/',
750
'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
752
'success', ('ok', 'yes', 'yes', 'yes', network_name))
753
a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
755
repo = a_bzrdir.create_repository()
756
# We should have got a remote repository
757
self.assertIsInstance(repo, remote.RemoteRepository)
758
# its format should have the settings from the response
759
format = repo._format
760
self.assertTrue(format.rich_root_data)
761
self.assertTrue(format.supports_tree_reference)
762
self.assertTrue(format.supports_external_lookups)
763
self.assertEqual(network_name, format.network_name())
766
class TestBzrDirOpenRepository(TestRemote):
768
def test_backwards_compat_1_2_3(self):
769
# fallback all the way to the first version.
770
reference_format = self.get_repo_format()
771
network_name = reference_format.network_name()
772
server_url = 'bzr://example.com/'
773
self.permit_url(server_url)
774
client = FakeClient(server_url)
775
client.add_unknown_method_response('BzrDir.find_repositoryV3')
776
client.add_unknown_method_response('BzrDir.find_repositoryV2')
777
client.add_success_response('ok', '', 'no', 'no')
778
# A real repository instance will be created to determine the network
780
client.add_success_response_with_body(
781
"Bazaar-NG meta directory, format 1\n", 'ok')
782
client.add_success_response_with_body(
783
reference_format.get_format_string(), 'ok')
784
# PackRepository wants to do a stat
785
client.add_success_response('stat', '0', '65535')
786
remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
788
bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
790
repo = bzrdir.open_repository()
792
[('call', 'BzrDir.find_repositoryV3', ('quack/',)),
793
('call', 'BzrDir.find_repositoryV2', ('quack/',)),
794
('call', 'BzrDir.find_repository', ('quack/',)),
795
('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
796
('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
797
('call', 'stat', ('/quack/.bzr/repository',)),
800
self.assertEqual(network_name, repo._format.network_name())
802
def test_backwards_compat_2(self):
803
# fallback to find_repositoryV2
804
reference_format = self.get_repo_format()
805
network_name = reference_format.network_name()
806
server_url = 'bzr://example.com/'
807
self.permit_url(server_url)
808
client = FakeClient(server_url)
809
client.add_unknown_method_response('BzrDir.find_repositoryV3')
810
client.add_success_response('ok', '', 'no', 'no', 'no')
811
# A real repository instance will be created to determine the network
813
client.add_success_response_with_body(
814
"Bazaar-NG meta directory, format 1\n", 'ok')
815
client.add_success_response_with_body(
816
reference_format.get_format_string(), 'ok')
817
# PackRepository wants to do a stat
818
client.add_success_response('stat', '0', '65535')
819
remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
821
bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
823
repo = bzrdir.open_repository()
825
[('call', 'BzrDir.find_repositoryV3', ('quack/',)),
826
('call', 'BzrDir.find_repositoryV2', ('quack/',)),
827
('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
828
('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
829
('call', 'stat', ('/quack/.bzr/repository',)),
832
self.assertEqual(network_name, repo._format.network_name())
834
def test_current_server(self):
835
reference_format = self.get_repo_format()
836
network_name = reference_format.network_name()
837
transport = MemoryTransport()
838
transport.mkdir('quack')
839
transport = transport.clone('quack')
840
client = FakeClient(transport.base)
841
client.add_success_response('ok', '', 'no', 'no', 'no', network_name)
842
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
844
repo = bzrdir.open_repository()
846
[('call', 'BzrDir.find_repositoryV3', ('quack/',))],
848
self.assertEqual(network_name, repo._format.network_name())
851
class TestBzrDirFormatInitializeEx(TestRemote):
853
def test_success(self):
854
"""Simple test for typical successful call."""
855
fmt = bzrdir.RemoteBzrDirFormat()
856
default_format_name = BzrDirFormat.get_default_format().network_name()
857
transport = self.get_transport()
858
client = FakeClient(transport.base)
859
client.add_expected_call(
860
'BzrDirFormat.initialize_ex_1.16',
861
(default_format_name, 'path', 'False', 'False', 'False', '',
862
'', '', '', 'False'),
864
('.', 'no', 'no', 'yes', 'repo fmt', 'repo bzrdir fmt',
865
'bzrdir fmt', 'False', '', '', 'repo lock token'))
866
# XXX: It would be better to call fmt.initialize_on_transport_ex, but
867
# it's currently hard to test that without supplying a real remote
868
# transport connected to a real server.
869
result = fmt._initialize_on_transport_ex_rpc(client, 'path',
870
transport, False, False, False, None, None, None, None, False)
871
self.assertFinished(client)
873
def test_error(self):
874
"""Error responses are translated, e.g. 'PermissionDenied' raises the
875
corresponding error from the client.
877
fmt = bzrdir.RemoteBzrDirFormat()
878
default_format_name = BzrDirFormat.get_default_format().network_name()
879
transport = self.get_transport()
880
client = FakeClient(transport.base)
881
client.add_expected_call(
882
'BzrDirFormat.initialize_ex_1.16',
883
(default_format_name, 'path', 'False', 'False', 'False', '',
884
'', '', '', 'False'),
886
('PermissionDenied', 'path', 'extra info'))
887
# XXX: It would be better to call fmt.initialize_on_transport_ex, but
888
# it's currently hard to test that without supplying a real remote
889
# transport connected to a real server.
890
err = self.assertRaises(errors.PermissionDenied,
891
fmt._initialize_on_transport_ex_rpc, client, 'path', transport,
892
False, False, False, None, None, None, None, False)
893
self.assertEqual('path', err.path)
894
self.assertEqual(': extra info', err.extra)
895
self.assertFinished(client)
897
def test_error_from_real_server(self):
898
"""Integration test for error translation."""
899
transport = self.make_smart_server('foo')
900
transport = transport.clone('no-such-path')
901
fmt = bzrdir.RemoteBzrDirFormat()
902
err = self.assertRaises(errors.NoSuchFile,
903
fmt.initialize_on_transport_ex, transport, create_prefix=False)
906
318
class OldSmartClient(object):
907
319
"""A fake smart client for test_old_version that just returns a version one
908
320
response to the 'hello' (query version) command.
931
343
return OldSmartClient()
934
class RemoteBzrDirTestCase(TestRemote):
936
def make_remote_bzrdir(self, transport, client):
937
"""Make a RemotebzrDir using 'client' as the _client."""
938
return RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
942
class RemoteBranchTestCase(RemoteBzrDirTestCase):
944
def lock_remote_branch(self, branch):
945
"""Trick a RemoteBranch into thinking it is locked."""
946
branch._lock_mode = 'w'
947
branch._lock_count = 2
948
branch._lock_token = 'branch token'
949
branch._repo_lock_token = 'repo token'
950
branch.repository._lock_mode = 'w'
951
branch.repository._lock_count = 2
952
branch.repository._lock_token = 'repo token'
954
def make_remote_branch(self, transport, client):
955
"""Make a RemoteBranch using 'client' as its _SmartClient.
957
A RemoteBzrDir and RemoteRepository will also be created to fill out
958
the RemoteBranch, albeit with stub values for some of their attributes.
960
# we do not want bzrdir to make any remote calls, so use False as its
961
# _client. If it tries to make a remote call, this will fail
963
bzrdir = self.make_remote_bzrdir(transport, False)
964
repo = RemoteRepository(bzrdir, None, _client=client)
965
branch_format = self.get_branch_format()
966
format = RemoteBranchFormat(network_name=branch_format.network_name())
967
return RemoteBranch(bzrdir, repo, _client=client, format=format)
970
class TestBranchGetParent(RemoteBranchTestCase):
972
def test_no_parent(self):
973
# in an empty branch we decode the response properly
974
transport = MemoryTransport()
975
client = FakeClient(transport.base)
976
client.add_expected_call(
977
'Branch.get_stacked_on_url', ('quack/',),
978
'error', ('NotStacked',))
979
client.add_expected_call(
980
'Branch.get_parent', ('quack/',),
982
transport.mkdir('quack')
983
transport = transport.clone('quack')
984
branch = self.make_remote_branch(transport, client)
985
result = branch.get_parent()
986
self.assertFinished(client)
987
self.assertEqual(None, result)
989
def test_parent_relative(self):
990
transport = MemoryTransport()
991
client = FakeClient(transport.base)
992
client.add_expected_call(
993
'Branch.get_stacked_on_url', ('kwaak/',),
994
'error', ('NotStacked',))
995
client.add_expected_call(
996
'Branch.get_parent', ('kwaak/',),
997
'success', ('../foo/',))
998
transport.mkdir('kwaak')
999
transport = transport.clone('kwaak')
1000
branch = self.make_remote_branch(transport, client)
1001
result = branch.get_parent()
1002
self.assertEqual(transport.clone('../foo').base, result)
1004
def test_parent_absolute(self):
1005
transport = MemoryTransport()
1006
client = FakeClient(transport.base)
1007
client.add_expected_call(
1008
'Branch.get_stacked_on_url', ('kwaak/',),
1009
'error', ('NotStacked',))
1010
client.add_expected_call(
1011
'Branch.get_parent', ('kwaak/',),
1012
'success', ('http://foo/',))
1013
transport.mkdir('kwaak')
1014
transport = transport.clone('kwaak')
1015
branch = self.make_remote_branch(transport, client)
1016
result = branch.get_parent()
1017
self.assertEqual('http://foo/', result)
1018
self.assertFinished(client)
1021
class TestBranchSetParentLocation(RemoteBranchTestCase):
1023
def test_no_parent(self):
1024
# We call the verb when setting parent to None
1025
transport = MemoryTransport()
1026
client = FakeClient(transport.base)
1027
client.add_expected_call(
1028
'Branch.get_stacked_on_url', ('quack/',),
1029
'error', ('NotStacked',))
1030
client.add_expected_call(
1031
'Branch.set_parent_location', ('quack/', 'b', 'r', ''),
1033
transport.mkdir('quack')
1034
transport = transport.clone('quack')
1035
branch = self.make_remote_branch(transport, client)
1036
branch._lock_token = 'b'
1037
branch._repo_lock_token = 'r'
1038
branch._set_parent_location(None)
1039
self.assertFinished(client)
1041
def test_parent(self):
1042
transport = MemoryTransport()
1043
client = FakeClient(transport.base)
1044
client.add_expected_call(
1045
'Branch.get_stacked_on_url', ('kwaak/',),
1046
'error', ('NotStacked',))
1047
client.add_expected_call(
1048
'Branch.set_parent_location', ('kwaak/', 'b', 'r', 'foo'),
1050
transport.mkdir('kwaak')
1051
transport = transport.clone('kwaak')
1052
branch = self.make_remote_branch(transport, client)
1053
branch._lock_token = 'b'
1054
branch._repo_lock_token = 'r'
1055
branch._set_parent_location('foo')
1056
self.assertFinished(client)
1058
def test_backwards_compat(self):
1059
self.setup_smart_server_with_call_log()
1060
branch = self.make_branch('.')
1061
self.reset_smart_call_log()
1062
verb = 'Branch.set_parent_location'
1063
self.disable_verb(verb)
1064
branch.set_parent('http://foo/')
1065
self.assertLength(12, self.hpss_calls)
1068
class TestBranchGetTagsBytes(RemoteBranchTestCase):
1070
def test_backwards_compat(self):
1071
self.setup_smart_server_with_call_log()
1072
branch = self.make_branch('.')
1073
self.reset_smart_call_log()
1074
verb = 'Branch.get_tags_bytes'
1075
self.disable_verb(verb)
1076
branch.tags.get_tag_dict()
1077
call_count = len([call for call in self.hpss_calls if
1078
call.call.method == verb])
1079
self.assertEqual(1, call_count)
1081
def test_trivial(self):
1082
transport = MemoryTransport()
1083
client = FakeClient(transport.base)
1084
client.add_expected_call(
1085
'Branch.get_stacked_on_url', ('quack/',),
1086
'error', ('NotStacked',))
1087
client.add_expected_call(
1088
'Branch.get_tags_bytes', ('quack/',),
1090
transport.mkdir('quack')
1091
transport = transport.clone('quack')
1092
branch = self.make_remote_branch(transport, client)
1093
result = branch.tags.get_tag_dict()
1094
self.assertFinished(client)
1095
self.assertEqual({}, result)
1098
class TestBranchSetTagsBytes(RemoteBranchTestCase):
1100
def test_trivial(self):
1101
transport = MemoryTransport()
1102
client = FakeClient(transport.base)
1103
client.add_expected_call(
1104
'Branch.get_stacked_on_url', ('quack/',),
1105
'error', ('NotStacked',))
1106
client.add_expected_call(
1107
'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1109
transport.mkdir('quack')
1110
transport = transport.clone('quack')
1111
branch = self.make_remote_branch(transport, client)
1112
self.lock_remote_branch(branch)
1113
branch._set_tags_bytes('tags bytes')
1114
self.assertFinished(client)
1115
self.assertEqual('tags bytes', client._calls[-1][-1])
1117
def test_backwards_compatible(self):
1118
transport = MemoryTransport()
1119
client = FakeClient(transport.base)
1120
client.add_expected_call(
1121
'Branch.get_stacked_on_url', ('quack/',),
1122
'error', ('NotStacked',))
1123
client.add_expected_call(
1124
'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1125
'unknown', ('Branch.set_tags_bytes',))
1126
transport.mkdir('quack')
1127
transport = transport.clone('quack')
1128
branch = self.make_remote_branch(transport, client)
1129
self.lock_remote_branch(branch)
1130
class StubRealBranch(object):
1133
def _set_tags_bytes(self, bytes):
1134
self.calls.append(('set_tags_bytes', bytes))
1135
real_branch = StubRealBranch()
1136
branch._real_branch = real_branch
1137
branch._set_tags_bytes('tags bytes')
1138
# Call a second time, to exercise the 'remote version already inferred'
1140
branch._set_tags_bytes('tags bytes')
1141
self.assertFinished(client)
1143
[('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1146
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
346
class TestBranchLastRevisionInfo(tests.TestCase):
1148
348
def test_empty_branch(self):
1149
349
# in an empty branch we decode the response properly
1150
350
transport = MemoryTransport()
1151
client = FakeClient(transport.base)
1152
client.add_expected_call(
1153
'Branch.get_stacked_on_url', ('quack/',),
1154
'error', ('NotStacked',))
1155
client.add_expected_call(
1156
'Branch.last_revision_info', ('quack/',),
1157
'success', ('ok', '0', 'null:'))
351
client = FakeClient([(('ok', '0', 'null:'), )], transport.base)
1158
352
transport.mkdir('quack')
1159
353
transport = transport.clone('quack')
1160
branch = self.make_remote_branch(transport, client)
354
# we do not want bzrdir to make any remote calls
355
bzrdir = RemoteBzrDir(transport, _client=False)
356
branch = RemoteBranch(bzrdir, None, _client=client)
1161
357
result = branch.last_revision_info()
1162
self.assertFinished(client)
360
[('call', 'Branch.last_revision_info', ('quack/',))],
1163
362
self.assertEqual((0, NULL_REVISION), result)
1165
364
def test_non_empty_branch(self):
1166
365
# in a non-empty branch we also decode the response properly
1167
366
revid = u'\xc8'.encode('utf8')
1168
367
transport = MemoryTransport()
1169
client = FakeClient(transport.base)
1170
client.add_expected_call(
1171
'Branch.get_stacked_on_url', ('kwaak/',),
1172
'error', ('NotStacked',))
1173
client.add_expected_call(
1174
'Branch.last_revision_info', ('kwaak/',),
1175
'success', ('ok', '2', revid))
368
client = FakeClient([(('ok', '2', revid), )], transport.base)
1176
369
transport.mkdir('kwaak')
1177
370
transport = transport.clone('kwaak')
1178
branch = self.make_remote_branch(transport, client)
371
# we do not want bzrdir to make any remote calls
372
bzrdir = RemoteBzrDir(transport, _client=False)
373
branch = RemoteBranch(bzrdir, None, _client=client)
1179
374
result = branch.last_revision_info()
377
[('call', 'Branch.last_revision_info', ('kwaak/',))],
1180
379
self.assertEqual((2, revid), result)
1183
class TestBranch_get_stacked_on_url(TestRemote):
1184
"""Test Branch._get_stacked_on_url rpc"""
1186
def test_get_stacked_on_invalid_url(self):
1187
# test that asking for a stacked on url the server can't access works.
1188
# This isn't perfect, but then as we're in the same process there
1189
# really isn't anything we can do to be 100% sure that the server
1190
# doesn't just open in - this test probably needs to be rewritten using
1191
# a spawn()ed server.
1192
stacked_branch = self.make_branch('stacked', format='1.9')
1193
memory_branch = self.make_branch('base', format='1.9')
1194
vfs_url = self.get_vfs_only_url('base')
1195
stacked_branch.set_stacked_on_url(vfs_url)
1196
transport = stacked_branch.bzrdir.root_transport
1197
client = FakeClient(transport.base)
1198
client.add_expected_call(
1199
'Branch.get_stacked_on_url', ('stacked/',),
1200
'success', ('ok', vfs_url))
1201
# XXX: Multiple calls are bad, this second call documents what is
1203
client.add_expected_call(
1204
'Branch.get_stacked_on_url', ('stacked/',),
1205
'success', ('ok', vfs_url))
1206
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
1208
repo_fmt = remote.RemoteRepositoryFormat()
1209
repo_fmt._custom_format = stacked_branch.repository._format
1210
branch = RemoteBranch(bzrdir, RemoteRepository(bzrdir, repo_fmt),
1212
result = branch.get_stacked_on_url()
1213
self.assertEqual(vfs_url, result)
1215
def test_backwards_compatible(self):
1216
# like with bzr1.6 with no Branch.get_stacked_on_url rpc
1217
base_branch = self.make_branch('base', format='1.6')
1218
stacked_branch = self.make_branch('stacked', format='1.6')
1219
stacked_branch.set_stacked_on_url('../base')
1220
client = FakeClient(self.get_url())
1221
branch_network_name = self.get_branch_format().network_name()
1222
client.add_expected_call(
1223
'BzrDir.open_branchV3', ('stacked/',),
1224
'success', ('branch', branch_network_name))
1225
client.add_expected_call(
1226
'BzrDir.find_repositoryV3', ('stacked/',),
1227
'success', ('ok', '', 'no', 'no', 'yes',
1228
stacked_branch.repository._format.network_name()))
1229
# called twice, once from constructor and then again by us
1230
client.add_expected_call(
1231
'Branch.get_stacked_on_url', ('stacked/',),
1232
'unknown', ('Branch.get_stacked_on_url',))
1233
client.add_expected_call(
1234
'Branch.get_stacked_on_url', ('stacked/',),
1235
'unknown', ('Branch.get_stacked_on_url',))
1236
# this will also do vfs access, but that goes direct to the transport
1237
# and isn't seen by the FakeClient.
1238
bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1239
remote.RemoteBzrDirFormat(), _client=client)
1240
branch = bzrdir.open_branch()
1241
result = branch.get_stacked_on_url()
1242
self.assertEqual('../base', result)
1243
self.assertFinished(client)
1244
# it's in the fallback list both for the RemoteRepository and its vfs
1246
self.assertEqual(1, len(branch.repository._fallback_repositories))
1248
len(branch.repository._real_repository._fallback_repositories))
1250
def test_get_stacked_on_real_branch(self):
1251
base_branch = self.make_branch('base')
1252
stacked_branch = self.make_branch('stacked')
1253
stacked_branch.set_stacked_on_url('../base')
1254
reference_format = self.get_repo_format()
1255
network_name = reference_format.network_name()
1256
client = FakeClient(self.get_url())
1257
branch_network_name = self.get_branch_format().network_name()
1258
client.add_expected_call(
1259
'BzrDir.open_branchV3', ('stacked/',),
1260
'success', ('branch', branch_network_name))
1261
client.add_expected_call(
1262
'BzrDir.find_repositoryV3', ('stacked/',),
1263
'success', ('ok', '', 'yes', 'no', 'yes', network_name))
1264
# called twice, once from constructor and then again by us
1265
client.add_expected_call(
1266
'Branch.get_stacked_on_url', ('stacked/',),
1267
'success', ('ok', '../base'))
1268
client.add_expected_call(
1269
'Branch.get_stacked_on_url', ('stacked/',),
1270
'success', ('ok', '../base'))
1271
bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1272
remote.RemoteBzrDirFormat(), _client=client)
1273
branch = bzrdir.open_branch()
1274
result = branch.get_stacked_on_url()
1275
self.assertEqual('../base', result)
1276
self.assertFinished(client)
1277
# it's in the fallback list both for the RemoteRepository.
1278
self.assertEqual(1, len(branch.repository._fallback_repositories))
1279
# And we haven't had to construct a real repository.
1280
self.assertEqual(None, branch.repository._real_repository)
1283
class TestBranchSetLastRevision(RemoteBranchTestCase):
382
class TestBranchSetLastRevision(tests.TestCase):
1285
384
def test_set_empty(self):
1286
385
# set_revision_history([]) is translated to calling
1323
418
transport.mkdir('branch')
1324
419
transport = transport.clone('branch')
1326
client = FakeClient(transport.base)
1327
client.add_expected_call(
1328
'Branch.get_stacked_on_url', ('branch/',),
1329
'error', ('NotStacked',))
1330
client.add_expected_call(
1331
'Branch.lock_write', ('branch/', '', ''),
1332
'success', ('ok', 'branch token', 'repo token'))
1333
client.add_expected_call(
1334
'Branch.last_revision_info',
1336
'success', ('ok', '0', 'null:'))
1338
encoded_body = bz2.compress('\n'.join(lines))
1339
client.add_success_response_with_body(encoded_body, 'ok')
1340
client.add_expected_call(
1341
'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'rev-id2',),
1343
client.add_expected_call(
1344
'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1346
branch = self.make_remote_branch(transport, client)
421
client = FakeClient([
423
(('ok', 'branch token', 'repo token'), ),
429
bzrdir = RemoteBzrDir(transport, _client=False)
430
branch = RemoteBranch(bzrdir, None, _client=client)
1347
431
# This is a hack to work around the problem that RemoteBranch currently
1348
432
# unnecessarily invokes _ensure_real upon a call to lock_write.
1349
433
branch._ensure_real = lambda: None
1350
434
# Lock the branch, reset the record of remote calls.
1351
435
branch.lock_write()
1352
438
result = branch.set_revision_history(['rev-id1', 'rev-id2'])
440
[('call', 'Branch.set_last_revision',
441
('branch/', 'branch token', 'repo token', 'rev-id2'))],
1354
444
self.assertEqual(None, result)
1355
self.assertFinished(client)
1357
446
def test_no_such_revision(self):
447
# A response of 'NoSuchRevision' is translated into an exception.
448
client = FakeClient([
450
(('ok', 'branch token', 'repo token'), ),
452
(('NoSuchRevision', 'rev-id'), ),
1358
455
transport = MemoryTransport()
1359
456
transport.mkdir('branch')
1360
457
transport = transport.clone('branch')
1361
# A response of 'NoSuchRevision' is translated into an exception.
1362
client = FakeClient(transport.base)
1363
client.add_expected_call(
1364
'Branch.get_stacked_on_url', ('branch/',),
1365
'error', ('NotStacked',))
1366
client.add_expected_call(
1367
'Branch.lock_write', ('branch/', '', ''),
1368
'success', ('ok', 'branch token', 'repo token'))
1369
client.add_expected_call(
1370
'Branch.last_revision_info',
1372
'success', ('ok', '0', 'null:'))
1373
# get_graph calls to construct the revision history, for the set_rh
1376
encoded_body = bz2.compress('\n'.join(lines))
1377
client.add_success_response_with_body(encoded_body, 'ok')
1378
client.add_expected_call(
1379
'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'rev-id',),
1380
'error', ('NoSuchRevision', 'rev-id'))
1381
client.add_expected_call(
1382
'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1385
branch = self.make_remote_branch(transport, client)
459
bzrdir = RemoteBzrDir(transport, _client=False)
460
branch = RemoteBranch(bzrdir, None, _client=client)
461
branch._ensure_real = lambda: None
1386
462
branch.lock_write()
1387
465
self.assertRaises(
1388
466
errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
1390
self.assertFinished(client)
1392
def test_tip_change_rejected(self):
1393
"""TipChangeRejected responses cause a TipChangeRejected exception to
1396
transport = MemoryTransport()
1397
transport.mkdir('branch')
1398
transport = transport.clone('branch')
1399
client = FakeClient(transport.base)
1400
rejection_msg_unicode = u'rejection message\N{INTERROBANG}'
1401
rejection_msg_utf8 = rejection_msg_unicode.encode('utf8')
1402
client.add_expected_call(
1403
'Branch.get_stacked_on_url', ('branch/',),
1404
'error', ('NotStacked',))
1405
client.add_expected_call(
1406
'Branch.lock_write', ('branch/', '', ''),
1407
'success', ('ok', 'branch token', 'repo token'))
1408
client.add_expected_call(
1409
'Branch.last_revision_info',
1411
'success', ('ok', '0', 'null:'))
1413
encoded_body = bz2.compress('\n'.join(lines))
1414
client.add_success_response_with_body(encoded_body, 'ok')
1415
client.add_expected_call(
1416
'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'rev-id',),
1417
'error', ('TipChangeRejected', rejection_msg_utf8))
1418
client.add_expected_call(
1419
'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1421
branch = self.make_remote_branch(transport, client)
1422
branch._ensure_real = lambda: None
1424
# The 'TipChangeRejected' error response triggered by calling
1425
# set_revision_history causes a TipChangeRejected exception.
1426
err = self.assertRaises(
1427
errors.TipChangeRejected, branch.set_revision_history, ['rev-id'])
1428
# The UTF-8 message from the response has been decoded into a unicode
1430
self.assertIsInstance(err.msg, unicode)
1431
self.assertEqual(rejection_msg_unicode, err.msg)
1433
self.assertFinished(client)
1436
class TestBranchSetLastRevisionInfo(RemoteBranchTestCase):
1438
def test_set_last_revision_info(self):
1439
# set_last_revision_info(num, 'rev-id') is translated to calling
1440
# Branch.set_last_revision_info(num, 'rev-id') on the wire.
1441
transport = MemoryTransport()
1442
transport.mkdir('branch')
1443
transport = transport.clone('branch')
1444
client = FakeClient(transport.base)
1445
# get_stacked_on_url
1446
client.add_error_response('NotStacked')
1448
client.add_success_response('ok', 'branch token', 'repo token')
1449
# query the current revision
1450
client.add_success_response('ok', '0', 'null:')
1452
client.add_success_response('ok')
1454
client.add_success_response('ok')
1456
branch = self.make_remote_branch(transport, client)
1457
# Lock the branch, reset the record of remote calls.
1460
result = branch.set_last_revision_info(1234, 'a-revision-id')
1462
[('call', 'Branch.last_revision_info', ('branch/',)),
1463
('call', 'Branch.set_last_revision_info',
1464
('branch/', 'branch token', 'repo token',
1465
'1234', 'a-revision-id'))],
1467
self.assertEqual(None, result)
1469
def test_no_such_revision(self):
1470
# A response of 'NoSuchRevision' is translated into an exception.
1471
transport = MemoryTransport()
1472
transport.mkdir('branch')
1473
transport = transport.clone('branch')
1474
client = FakeClient(transport.base)
1475
# get_stacked_on_url
1476
client.add_error_response('NotStacked')
1478
client.add_success_response('ok', 'branch token', 'repo token')
1480
client.add_error_response('NoSuchRevision', 'revid')
1482
client.add_success_response('ok')
1484
branch = self.make_remote_branch(transport, client)
1485
# Lock the branch, reset the record of remote calls.
1490
errors.NoSuchRevision, branch.set_last_revision_info, 123, 'revid')
1493
def test_backwards_compatibility(self):
1494
"""If the server does not support the Branch.set_last_revision_info
1495
verb (which is new in 1.4), then the client falls back to VFS methods.
1497
# This test is a little messy. Unlike most tests in this file, it
1498
# doesn't purely test what a Remote* object sends over the wire, and
1499
# how it reacts to responses from the wire. It instead relies partly
1500
# on asserting that the RemoteBranch will call
1501
# self._real_branch.set_last_revision_info(...).
1503
# First, set up our RemoteBranch with a FakeClient that raises
1504
# UnknownSmartMethod, and a StubRealBranch that logs how it is called.
1505
transport = MemoryTransport()
1506
transport.mkdir('branch')
1507
transport = transport.clone('branch')
1508
client = FakeClient(transport.base)
1509
client.add_expected_call(
1510
'Branch.get_stacked_on_url', ('branch/',),
1511
'error', ('NotStacked',))
1512
client.add_expected_call(
1513
'Branch.last_revision_info',
1515
'success', ('ok', '0', 'null:'))
1516
client.add_expected_call(
1517
'Branch.set_last_revision_info',
1518
('branch/', 'branch token', 'repo token', '1234', 'a-revision-id',),
1519
'unknown', 'Branch.set_last_revision_info')
1521
branch = self.make_remote_branch(transport, client)
1522
class StubRealBranch(object):
1525
def set_last_revision_info(self, revno, revision_id):
1527
('set_last_revision_info', revno, revision_id))
1528
def _clear_cached_state(self):
1530
real_branch = StubRealBranch()
1531
branch._real_branch = real_branch
1532
self.lock_remote_branch(branch)
1534
# Call set_last_revision_info, and verify it behaved as expected.
1535
result = branch.set_last_revision_info(1234, 'a-revision-id')
1537
[('set_last_revision_info', 1234, 'a-revision-id')],
1539
self.assertFinished(client)
1541
def test_unexpected_error(self):
1542
# If the server sends an error the client doesn't understand, it gets
1543
# turned into an UnknownErrorFromSmartServer, which is presented as a
1544
# non-internal error to the user.
1545
transport = MemoryTransport()
1546
transport.mkdir('branch')
1547
transport = transport.clone('branch')
1548
client = FakeClient(transport.base)
1549
# get_stacked_on_url
1550
client.add_error_response('NotStacked')
1552
client.add_success_response('ok', 'branch token', 'repo token')
1554
client.add_error_response('UnexpectedError')
1556
client.add_success_response('ok')
1558
branch = self.make_remote_branch(transport, client)
1559
# Lock the branch, reset the record of remote calls.
1563
err = self.assertRaises(
1564
errors.UnknownErrorFromSmartServer,
1565
branch.set_last_revision_info, 123, 'revid')
1566
self.assertEqual(('UnexpectedError',), err.error_tuple)
1569
def test_tip_change_rejected(self):
1570
"""TipChangeRejected responses cause a TipChangeRejected exception to
1573
transport = MemoryTransport()
1574
transport.mkdir('branch')
1575
transport = transport.clone('branch')
1576
client = FakeClient(transport.base)
1577
# get_stacked_on_url
1578
client.add_error_response('NotStacked')
1580
client.add_success_response('ok', 'branch token', 'repo token')
1582
client.add_error_response('TipChangeRejected', 'rejection message')
1584
client.add_success_response('ok')
1586
branch = self.make_remote_branch(transport, client)
1587
# Lock the branch, reset the record of remote calls.
1589
self.addCleanup(branch.unlock)
1592
# The 'TipChangeRejected' error response triggered by calling
1593
# set_last_revision_info causes a TipChangeRejected exception.
1594
err = self.assertRaises(
1595
errors.TipChangeRejected,
1596
branch.set_last_revision_info, 123, 'revid')
1597
self.assertEqual('rejection message', err.msg)
1600
class TestBranchGetSetConfig(RemoteBranchTestCase):
470
class TestBranchControlGetBranchConf(tests.TestCaseWithMemoryTransport):
471
"""Test branch.control_files api munging...
473
We special case RemoteBranch.control_files.get('branch.conf') to
474
call a specific API so that RemoteBranch's can intercept configuration
475
file reading, allowing them to signal to the client about things like
476
'email is configured for commits'.
1602
479
def test_get_branch_conf(self):
1603
480
# in an empty branch we decode the response properly
1604
client = FakeClient()
1605
client.add_expected_call(
1606
'Branch.get_stacked_on_url', ('memory:///',),
1607
'error', ('NotStacked',),)
1608
client.add_success_response_with_body('# config file body', 'ok')
1609
transport = MemoryTransport()
1610
branch = self.make_remote_branch(transport, client)
1611
config = branch.get_config()
1612
config.has_explicit_nickname()
481
client = FakeClient([(('ok', ), 'config file body')], self.get_url())
482
# we need to make a real branch because the remote_branch.control_files
483
# will trigger _ensure_real.
484
branch = self.make_branch('quack')
485
transport = branch.bzrdir.root_transport
486
# we do not want bzrdir to make any remote calls
487
bzrdir = RemoteBzrDir(transport, _client=False)
488
branch = RemoteBranch(bzrdir, None, _client=client)
489
result = branch.control_files.get('branch.conf')
1613
490
self.assertEqual(
1614
[('call', 'Branch.get_stacked_on_url', ('memory:///',)),
1615
('call_expecting_body', 'Branch.get_config_file', ('memory:///',))],
491
[('call_expecting_body', 'Branch.get_config_file', ('quack/',))],
1618
def test_get_multi_line_branch_conf(self):
1619
# Make sure that multiple-line branch.conf files are supported
1621
# https://bugs.edge.launchpad.net/bzr/+bug/354075
1622
client = FakeClient()
1623
client.add_expected_call(
1624
'Branch.get_stacked_on_url', ('memory:///',),
1625
'error', ('NotStacked',),)
1626
client.add_success_response_with_body('a = 1\nb = 2\nc = 3\n', 'ok')
1627
transport = MemoryTransport()
1628
branch = self.make_remote_branch(transport, client)
1629
config = branch.get_config()
1630
self.assertEqual(u'2', config.get_user_option('b'))
1632
def test_set_option(self):
1633
client = FakeClient()
1634
client.add_expected_call(
1635
'Branch.get_stacked_on_url', ('memory:///',),
1636
'error', ('NotStacked',),)
1637
client.add_expected_call(
1638
'Branch.lock_write', ('memory:///', '', ''),
1639
'success', ('ok', 'branch token', 'repo token'))
1640
client.add_expected_call(
1641
'Branch.set_config_option', ('memory:///', 'branch token',
1642
'repo token', 'foo', 'bar', ''),
1644
client.add_expected_call(
1645
'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
1647
transport = MemoryTransport()
1648
branch = self.make_remote_branch(transport, client)
1650
config = branch._get_config()
1651
config.set_option('foo', 'bar')
1653
self.assertFinished(client)
1655
def test_backwards_compat_set_option(self):
1656
self.setup_smart_server_with_call_log()
1657
branch = self.make_branch('.')
1658
verb = 'Branch.set_config_option'
1659
self.disable_verb(verb)
1661
self.addCleanup(branch.unlock)
1662
self.reset_smart_call_log()
1663
branch._get_config().set_option('value', 'name')
1664
self.assertLength(10, self.hpss_calls)
1665
self.assertEqual('value', branch._get_config().get_option('name'))
1668
class TestBranchLockWrite(RemoteBranchTestCase):
493
self.assertEqual('config file body', result.read())
496
class TestBranchLockWrite(tests.TestCase):
1670
498
def test_lock_write_unlockable(self):
1671
499
transport = MemoryTransport()
1672
client = FakeClient(transport.base)
1673
client.add_expected_call(
1674
'Branch.get_stacked_on_url', ('quack/',),
1675
'error', ('NotStacked',),)
1676
client.add_expected_call(
1677
'Branch.lock_write', ('quack/', '', ''),
1678
'error', ('UnlockableTransport',))
500
client = FakeClient([(('UnlockableTransport', ), '')], transport.base)
1679
501
transport.mkdir('quack')
1680
502
transport = transport.clone('quack')
1681
branch = self.make_remote_branch(transport, client)
503
# we do not want bzrdir to make any remote calls
504
bzrdir = RemoteBzrDir(transport, _client=False)
505
branch = RemoteBranch(bzrdir, None, _client=client)
1682
506
self.assertRaises(errors.UnlockableTransport, branch.lock_write)
1683
self.assertFinished(client)
1686
class TestBzrDirGetSetConfig(RemoteBzrDirTestCase):
1688
def test__get_config(self):
1689
client = FakeClient()
1690
client.add_success_response_with_body('default_stack_on = /\n', 'ok')
1691
transport = MemoryTransport()
1692
bzrdir = self.make_remote_bzrdir(transport, client)
1693
config = bzrdir.get_config()
1694
self.assertEqual('/', config.get_default_stack_on())
1695
507
self.assertEqual(
1696
[('call_expecting_body', 'BzrDir.get_config_file', ('memory:///',))],
508
[('call', 'Branch.lock_write', ('quack/', '', ''))],
1699
def test_set_option_uses_vfs(self):
1700
self.setup_smart_server_with_call_log()
1701
bzrdir = self.make_bzrdir('.')
1702
self.reset_smart_call_log()
1703
config = bzrdir.get_config()
1704
config.set_default_stack_on('/')
1705
self.assertLength(3, self.hpss_calls)
1707
def test_backwards_compat_get_option(self):
1708
self.setup_smart_server_with_call_log()
1709
bzrdir = self.make_bzrdir('.')
1710
verb = 'BzrDir.get_config_file'
1711
self.disable_verb(verb)
1712
self.reset_smart_call_log()
1713
self.assertEqual(None,
1714
bzrdir._get_config().get_option('default_stack_on'))
1715
self.assertLength(3, self.hpss_calls)
1718
512
class TestTransportIsReadonly(tests.TestCase):
1720
514
def test_true(self):
1721
client = FakeClient()
1722
client.add_success_response('yes')
515
client = FakeClient([(('yes',), '')])
1723
516
transport = RemoteTransport('bzr://example.com/', medium=False,
1725
518
self.assertEqual(True, transport.is_readonly())
1740
532
def test_error_from_old_server(self):
1741
533
"""bzr 0.15 and earlier servers don't recognise the is_readonly verb.
1743
535
Clients should treat it as a "no" response, because is_readonly is only
1744
536
advisory anyway (a transport could be read-write, but then the
1745
537
underlying filesystem could be readonly anyway).
1747
client = FakeClient()
1748
client.add_unknown_method_response('Transport.is_readonly')
1749
transport = RemoteTransport('bzr://example.com/', medium=False,
1751
self.assertEqual(False, transport.is_readonly())
1753
[('call', 'Transport.is_readonly', ())],
1757
class TestTransportMkdir(tests.TestCase):
1759
def test_permissiondenied(self):
1760
client = FakeClient()
1761
client.add_error_response('PermissionDenied', 'remote path', 'extra')
1762
transport = RemoteTransport('bzr://example.com/', medium=False,
1764
exc = self.assertRaises(
1765
errors.PermissionDenied, transport.mkdir, 'client path')
1766
expected_error = errors.PermissionDenied('/client path', 'extra')
1767
self.assertEqual(expected_error, exc)
1770
class TestRemoteSSHTransportAuthentication(tests.TestCaseInTempDir):
1772
def test_defaults_to_none(self):
1773
t = RemoteSSHTransport('bzr+ssh://example.com')
1774
self.assertIs(None, t._get_credentials()[0])
1776
def test_uses_authentication_config(self):
1777
conf = config.AuthenticationConfig()
1778
conf._get_config().update(
1779
{'bzr+sshtest': {'scheme': 'ssh', 'user': 'bar', 'host':
1782
t = RemoteSSHTransport('bzr+ssh://example.com')
1783
self.assertEqual('bar', t._get_credentials()[0])
1786
class TestRemoteRepository(TestRemote):
539
client = FakeClient([(
540
('error', "Generic bzr smart protocol error: "
541
"bad request 'Transport.is_readonly'"), '')])
542
transport = RemoteTransport('bzr://example.com/', medium=False,
544
self.assertEqual(False, transport.is_readonly())
546
[('call', 'Transport.is_readonly', ())],
549
def test_error_from_old_0_11_server(self):
550
"""Same as test_error_from_old_server, but with the slightly different
551
error message from bzr 0.11 servers.
553
client = FakeClient([(
554
('error', "Generic bzr smart protocol error: "
555
"bad request u'Transport.is_readonly'"), '')])
556
transport = RemoteTransport('bzr://example.com/', medium=False,
558
self.assertEqual(False, transport.is_readonly())
560
[('call', 'Transport.is_readonly', ())],
564
class TestRemoteRepository(tests.TestCase):
1787
565
"""Base for testing RemoteRepository protocol usage.
1789
These tests contain frozen requests and responses. We want any changes to
567
These tests contain frozen requests and responses. We want any changes to
1790
568
what is sent or expected to be require a thoughtful update to these tests
1791
569
because they might break compatibility with different-versioned servers.
1794
def setup_fake_client_and_repository(self, transport_path):
572
def setup_fake_client_and_repository(self, responses, transport_path):
1795
573
"""Create the fake client and repository for testing with.
1797
575
There's no real server here; we just have canned responses sent
1798
576
back one by one.
1800
578
:param transport_path: Path below the root of the MemoryTransport
1801
579
where the repository will be created.
1803
581
transport = MemoryTransport()
1804
582
transport.mkdir(transport_path)
1805
client = FakeClient(transport.base)
583
client = FakeClient(responses, transport.base)
1806
584
transport = transport.clone(transport_path)
1807
585
# we do not want bzrdir to make any remote calls
1808
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
586
bzrdir = RemoteBzrDir(transport, _client=False)
1810
587
repo = RemoteRepository(bzrdir, None, _client=client)
1811
588
return repo, client
1814
def remoted_description(format):
1815
return 'Remote: ' + format.get_format_description()
1818
class TestBranchFormat(tests.TestCase):
1820
def test_get_format_description(self):
1821
remote_format = RemoteBranchFormat()
1822
real_format = branch.BranchFormat.get_default_format()
1823
remote_format._network_name = real_format.network_name()
1824
self.assertEqual(remoted_description(real_format),
1825
remote_format.get_format_description())
1828
class TestRepositoryFormat(TestRemoteRepository):
1830
def test_fast_delta(self):
1831
true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
1832
true_format = RemoteRepositoryFormat()
1833
true_format._network_name = true_name
1834
self.assertEqual(True, true_format.fast_deltas)
1835
false_name = pack_repo.RepositoryFormatKnitPack1().network_name()
1836
false_format = RemoteRepositoryFormat()
1837
false_format._network_name = false_name
1838
self.assertEqual(False, false_format.fast_deltas)
1840
def test_get_format_description(self):
1841
remote_repo_format = RemoteRepositoryFormat()
1842
real_format = repository.RepositoryFormat.get_default_format()
1843
remote_repo_format._network_name = real_format.network_name()
1844
self.assertEqual(remoted_description(real_format),
1845
remote_repo_format.get_format_description())
1848
591
class TestRepositoryGatherStats(TestRemoteRepository):
1850
593
def test_revid_none(self):
1851
594
# ('ok',), body with revisions and size
595
responses = [(('ok', ), 'revisions: 2\nsize: 18\n')]
1852
596
transport_path = 'quack'
1853
repo, client = self.setup_fake_client_and_repository(transport_path)
1854
client.add_success_response_with_body(
1855
'revisions: 2\nsize: 18\n', 'ok')
597
repo, client = self.setup_fake_client_and_repository(
598
responses, transport_path)
1856
599
result = repo.gather_stats(None)
1857
600
self.assertEqual(
1858
601
[('call_expecting_body', 'Repository.gather_stats',
1949
696
self.assertEqual({r1: (NULL_REVISION,)}, parents)
1950
697
self.assertEqual(
1951
698
[('call_with_body_bytes_expecting_body',
1952
'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
699
'Repository.get_parent_map', ('quack/', r2), '\n\n0'),
1954
700
('call_with_body_bytes_expecting_body',
1955
'Repository.get_parent_map', ('quack/', 'include-missing:', r1),
701
'Repository.get_parent_map', ('quack/', r1), '\n\n0'),
1961
706
def test_get_parent_map_reconnects_if_unknown_method(self):
708
"Generic bzr smart protocol error: "
709
"bad request 'Repository.get_parent_map'")
711
(('error', error_msg), ''),
1962
713
transport_path = 'quack'
714
repo, client = self.setup_fake_client_and_repository(
715
responses, transport_path)
1963
716
rev_id = 'revision-id'
1964
repo, client = self.setup_fake_client_and_repository(transport_path)
1965
client.add_unknown_method_response('Repository.get_parent_map')
1966
client.add_success_response_with_body(rev_id, 'ok')
1967
self.assertFalse(client._medium._is_remote_before((1, 2)))
1968
717
parents = repo.get_parent_map([rev_id])
1969
718
self.assertEqual(
1970
719
[('call_with_body_bytes_expecting_body',
1971
'Repository.get_parent_map', ('quack/', 'include-missing:',
720
'Repository.get_parent_map', ('quack/', rev_id), '\n\n0'),
1973
721
('disconnect medium',),
1974
722
('call_expecting_body', 'Repository.get_revision_graph',
1975
723
('quack/', ''))],
1977
# The medium is now marked as being connected to an older server
1978
self.assertTrue(client._medium._is_remote_before((1, 2)))
1979
self.assertEqual({rev_id: ('null:',)}, parents)
1981
def test_get_parent_map_fallback_parentless_node(self):
1982
"""get_parent_map falls back to get_revision_graph on old servers. The
1983
results from get_revision_graph are tweaked to match the get_parent_map
1986
Specifically, a {key: ()} result from get_revision_graph means "no
1987
parents" for that key, which in get_parent_map results should be
1988
represented as {key: ('null:',)}.
1990
This is the test for https://bugs.launchpad.net/bzr/+bug/214894
1992
rev_id = 'revision-id'
1993
transport_path = 'quack'
1994
repo, client = self.setup_fake_client_and_repository(transport_path)
1995
client.add_success_response_with_body(rev_id, 'ok')
1996
client._medium._remember_remote_is_before((1, 2))
1997
parents = repo.get_parent_map([rev_id])
1999
[('call_expecting_body', 'Repository.get_revision_graph',
2002
self.assertEqual({rev_id: ('null:',)}, parents)
2004
def test_get_parent_map_unexpected_response(self):
2005
repo, client = self.setup_fake_client_and_repository('path')
2006
client.add_success_response('something unexpected!')
2008
errors.UnexpectedSmartServerResponse,
2009
repo.get_parent_map, ['a-revision-id'])
2011
def test_get_parent_map_negative_caches_missing_keys(self):
2012
self.setup_smart_server_with_call_log()
2013
repo = self.make_repository('foo')
2014
self.assertIsInstance(repo, RemoteRepository)
2016
self.addCleanup(repo.unlock)
2017
self.reset_smart_call_log()
2018
graph = repo.get_graph()
2019
self.assertEqual({},
2020
graph.get_parent_map(['some-missing', 'other-missing']))
2021
self.assertLength(1, self.hpss_calls)
2022
# No call if we repeat this
2023
self.reset_smart_call_log()
2024
graph = repo.get_graph()
2025
self.assertEqual({},
2026
graph.get_parent_map(['some-missing', 'other-missing']))
2027
self.assertLength(0, self.hpss_calls)
2028
# Asking for more unknown keys makes a request.
2029
self.reset_smart_call_log()
2030
graph = repo.get_graph()
2031
self.assertEqual({},
2032
graph.get_parent_map(['some-missing', 'other-missing',
2034
self.assertLength(1, self.hpss_calls)
2036
def disableExtraResults(self):
2037
self.overrideAttr(SmartServerRepositoryGetParentMap,
2038
'no_extra_results', True)
2040
def test_null_cached_missing_and_stop_key(self):
2041
self.setup_smart_server_with_call_log()
2042
# Make a branch with a single revision.
2043
builder = self.make_branch_builder('foo')
2044
builder.start_series()
2045
builder.build_snapshot('first', None, [
2046
('add', ('', 'root-id', 'directory', ''))])
2047
builder.finish_series()
2048
branch = builder.get_branch()
2049
repo = branch.repository
2050
self.assertIsInstance(repo, RemoteRepository)
2051
# Stop the server from sending extra results.
2052
self.disableExtraResults()
2054
self.addCleanup(repo.unlock)
2055
self.reset_smart_call_log()
2056
graph = repo.get_graph()
2057
# Query for 'first' and 'null:'. Because 'null:' is a parent of
2058
# 'first' it will be a candidate for the stop_keys of subsequent
2059
# requests, and because 'null:' was queried but not returned it will be
2060
# cached as missing.
2061
self.assertEqual({'first': ('null:',)},
2062
graph.get_parent_map(['first', 'null:']))
2063
# Now query for another key. This request will pass along a recipe of
2064
# start and stop keys describing the already cached results, and this
2065
# recipe's revision count must be correct (or else it will trigger an
2066
# error from the server).
2067
self.assertEqual({}, graph.get_parent_map(['another-key']))
2068
# This assertion guards against disableExtraResults silently failing to
2069
# work, thus invalidating the test.
2070
self.assertLength(2, self.hpss_calls)
2072
def test_get_parent_map_gets_ghosts_from_result(self):
2073
# asking for a revision should negatively cache close ghosts in its
2075
self.setup_smart_server_with_call_log()
2076
tree = self.make_branch_and_memory_tree('foo')
2079
builder = treebuilder.TreeBuilder()
2080
builder.start_tree(tree)
2082
builder.finish_tree()
2083
tree.set_parent_ids(['non-existant'], allow_leftmost_as_ghost=True)
2084
rev_id = tree.commit('')
2088
self.addCleanup(tree.unlock)
2089
repo = tree.branch.repository
2090
self.assertIsInstance(repo, RemoteRepository)
2092
repo.get_parent_map([rev_id])
2093
self.reset_smart_call_log()
2094
# Now asking for rev_id's ghost parent should not make calls
2095
self.assertEqual({}, repo.get_parent_map(['non-existant']))
2096
self.assertLength(0, self.hpss_calls)
2099
class TestGetParentMapAllowsNew(tests.TestCaseWithTransport):
2101
def test_allows_new_revisions(self):
2102
"""get_parent_map's results can be updated by commit."""
2103
smart_server = test_server.SmartTCPServer_for_testing()
2104
self.start_server(smart_server)
2105
self.make_branch('branch')
2106
branch = Branch.open(smart_server.get_url() + '/branch')
2107
tree = branch.create_checkout('tree', lightweight=True)
2109
self.addCleanup(tree.unlock)
2110
graph = tree.branch.repository.get_graph()
2111
# This provides an opportunity for the missing rev-id to be cached.
2112
self.assertEqual({}, graph.get_parent_map(['rev1']))
2113
tree.commit('message', rev_id='rev1')
2114
graph = tree.branch.repository.get_graph()
2115
self.assertEqual({'rev1': ('null:',)}, graph.get_parent_map(['rev1']))
2118
728
class TestRepositoryGetRevisionGraph(TestRemoteRepository):
2120
730
def test_null_revision(self):
2121
731
# a null revision has the predictable result {}, we should have no wire
2122
732
# traffic when calling it with this argument
733
responses = [(('notused', ), '')]
2123
734
transport_path = 'empty'
2124
repo, client = self.setup_fake_client_and_repository(transport_path)
2125
client.add_success_response('notused')
2126
# actual RemoteRepository.get_revision_graph is gone, but there's an
2127
# equivalent private method for testing
2128
result = repo._get_revision_graph(NULL_REVISION)
735
repo, client = self.setup_fake_client_and_repository(
736
responses, transport_path)
737
result = self.applyDeprecated(one_four, repo.get_revision_graph,
2129
739
self.assertEqual([], client._calls)
2130
740
self.assertEqual({}, result)
2170
780
def test_no_such_revision(self):
782
responses = [(('nosuchrevision', revid), '')]
2172
783
transport_path = 'sinhala'
2173
repo, client = self.setup_fake_client_and_repository(transport_path)
2174
client.add_error_response('nosuchrevision', revid)
784
repo, client = self.setup_fake_client_and_repository(
785
responses, transport_path)
2175
786
# also check that the right revision is reported in the error
2176
787
self.assertRaises(errors.NoSuchRevision,
2177
repo._get_revision_graph, revid)
788
self.applyDeprecated, one_four, repo.get_revision_graph, revid)
2178
789
self.assertEqual(
2179
790
[('call_expecting_body', 'Repository.get_revision_graph',
2180
791
('sinhala/', revid))],
2183
def test_unexpected_error(self):
2185
transport_path = 'sinhala'
2186
repo, client = self.setup_fake_client_and_repository(transport_path)
2187
client.add_error_response('AnUnexpectedError')
2188
e = self.assertRaises(errors.UnknownErrorFromSmartServer,
2189
repo._get_revision_graph, revid)
2190
self.assertEqual(('AnUnexpectedError',), e.error_tuple)
2193
class TestRepositoryGetRevIdForRevno(TestRemoteRepository):
2196
repo, client = self.setup_fake_client_and_repository('quack')
2197
client.add_expected_call(
2198
'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2199
'success', ('ok', 'rev-five'))
2200
result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
2201
self.assertEqual((True, 'rev-five'), result)
2202
self.assertFinished(client)
2204
def test_history_incomplete(self):
2205
repo, client = self.setup_fake_client_and_repository('quack')
2206
client.add_expected_call(
2207
'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2208
'success', ('history-incomplete', 10, 'rev-ten'))
2209
result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
2210
self.assertEqual((False, (10, 'rev-ten')), result)
2211
self.assertFinished(client)
2213
def test_history_incomplete_with_fallback(self):
2214
"""A 'history-incomplete' response causes the fallback repository to be
2215
queried too, if one is set.
2217
# Make a repo with a fallback repo, both using a FakeClient.
2218
format = remote.response_tuple_to_repo_format(
2219
('yes', 'no', 'yes', self.get_repo_format().network_name()))
2220
repo, client = self.setup_fake_client_and_repository('quack')
2221
repo._format = format
2222
fallback_repo, ignored = self.setup_fake_client_and_repository(
2224
fallback_repo._client = client
2225
fallback_repo._format = format
2226
repo.add_fallback_repository(fallback_repo)
2227
# First the client should ask the primary repo
2228
client.add_expected_call(
2229
'Repository.get_rev_id_for_revno', ('quack/', 1, (42, 'rev-foo')),
2230
'success', ('history-incomplete', 2, 'rev-two'))
2231
# Then it should ask the fallback, using revno/revid from the
2232
# history-incomplete response as the known revno/revid.
2233
client.add_expected_call(
2234
'Repository.get_rev_id_for_revno',('fallback/', 1, (2, 'rev-two')),
2235
'success', ('ok', 'rev-one'))
2236
result = repo.get_rev_id_for_revno(1, (42, 'rev-foo'))
2237
self.assertEqual((True, 'rev-one'), result)
2238
self.assertFinished(client)
2240
def test_nosuchrevision(self):
2241
# 'nosuchrevision' is returned when the known-revid is not found in the
2242
# remote repo. The client translates that response to NoSuchRevision.
2243
repo, client = self.setup_fake_client_and_repository('quack')
2244
client.add_expected_call(
2245
'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2246
'error', ('nosuchrevision', 'rev-foo'))
2248
errors.NoSuchRevision,
2249
repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
2250
self.assertFinished(client)
2252
def test_branch_fallback_locking(self):
2253
"""RemoteBranch.get_rev_id takes a read lock, and tries to call the
2254
get_rev_id_for_revno verb. If the verb is unknown the VFS fallback
2255
will be invoked, which will fail if the repo is unlocked.
2257
self.setup_smart_server_with_call_log()
2258
tree = self.make_branch_and_memory_tree('.')
2260
rev1 = tree.commit('First')
2261
rev2 = tree.commit('Second')
2263
branch = tree.branch
2264
self.assertFalse(branch.is_locked())
2265
self.reset_smart_call_log()
2266
verb = 'Repository.get_rev_id_for_revno'
2267
self.disable_verb(verb)
2268
self.assertEqual(rev1, branch.get_rev_id(1))
2269
self.assertLength(1, [call for call in self.hpss_calls if
2270
call.call.method == verb])
2273
795
class TestRepositoryIsShared(TestRemoteRepository):
2275
797
def test_is_shared(self):
2276
798
# ('yes', ) for Repository.is_shared -> 'True'.
799
responses = [(('yes', ), )]
2277
800
transport_path = 'quack'
2278
repo, client = self.setup_fake_client_and_repository(transport_path)
2279
client.add_success_response('yes')
801
repo, client = self.setup_fake_client_and_repository(
802
responses, transport_path)
2280
803
result = repo.is_shared()
2281
804
self.assertEqual(
2282
805
[('call', 'Repository.is_shared', ('quack/',))],
2390
895
self.assertEqual([], client._calls)
2393
class TestRepositoryInsertStreamBase(TestRemoteRepository):
2394
"""Base class for Repository.insert_stream and .insert_stream_1.19
2398
def checkInsertEmptyStream(self, repo, client):
2399
"""Insert an empty stream, checking the result.
2401
This checks that there are no resume_tokens or missing_keys, and that
2402
the client is finished.
2404
sink = repo._get_sink()
2405
fmt = repository.RepositoryFormat.get_default_format()
2406
resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2407
self.assertEqual([], resume_tokens)
2408
self.assertEqual(set(), missing_keys)
2409
self.assertFinished(client)
2412
class TestRepositoryInsertStream(TestRepositoryInsertStreamBase):
2413
"""Tests for using Repository.insert_stream verb when the _1.19 variant is
2416
This test case is very similar to TestRepositoryInsertStream_1_19.
2420
TestRemoteRepository.setUp(self)
2421
self.disable_verb('Repository.insert_stream_1.19')
2423
def test_unlocked_repo(self):
2424
transport_path = 'quack'
2425
repo, client = self.setup_fake_client_and_repository(transport_path)
2426
client.add_expected_call(
2427
'Repository.insert_stream_1.19', ('quack/', ''),
2428
'unknown', ('Repository.insert_stream_1.19',))
2429
client.add_expected_call(
2430
'Repository.insert_stream', ('quack/', ''),
2432
client.add_expected_call(
2433
'Repository.insert_stream', ('quack/', ''),
2435
self.checkInsertEmptyStream(repo, client)
2437
def test_locked_repo_with_no_lock_token(self):
2438
transport_path = 'quack'
2439
repo, client = self.setup_fake_client_and_repository(transport_path)
2440
client.add_expected_call(
2441
'Repository.lock_write', ('quack/', ''),
2442
'success', ('ok', ''))
2443
client.add_expected_call(
2444
'Repository.insert_stream_1.19', ('quack/', ''),
2445
'unknown', ('Repository.insert_stream_1.19',))
2446
client.add_expected_call(
2447
'Repository.insert_stream', ('quack/', ''),
2449
client.add_expected_call(
2450
'Repository.insert_stream', ('quack/', ''),
2453
self.checkInsertEmptyStream(repo, client)
2455
def test_locked_repo_with_lock_token(self):
2456
transport_path = 'quack'
2457
repo, client = self.setup_fake_client_and_repository(transport_path)
2458
client.add_expected_call(
2459
'Repository.lock_write', ('quack/', ''),
2460
'success', ('ok', 'a token'))
2461
client.add_expected_call(
2462
'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2463
'unknown', ('Repository.insert_stream_1.19',))
2464
client.add_expected_call(
2465
'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2467
client.add_expected_call(
2468
'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2471
self.checkInsertEmptyStream(repo, client)
2473
def test_stream_with_inventory_deltas(self):
2474
"""'inventory-deltas' substreams cannot be sent to the
2475
Repository.insert_stream verb, because not all servers that implement
2476
that verb will accept them. So when one is encountered the RemoteSink
2477
immediately stops using that verb and falls back to VFS insert_stream.
2479
transport_path = 'quack'
2480
repo, client = self.setup_fake_client_and_repository(transport_path)
2481
client.add_expected_call(
2482
'Repository.insert_stream_1.19', ('quack/', ''),
2483
'unknown', ('Repository.insert_stream_1.19',))
2484
client.add_expected_call(
2485
'Repository.insert_stream', ('quack/', ''),
2487
client.add_expected_call(
2488
'Repository.insert_stream', ('quack/', ''),
2490
# Create a fake real repository for insert_stream to fall back on, so
2491
# that we can directly see the records the RemoteSink passes to the
2496
def insert_stream(self, stream, src_format, resume_tokens):
2497
for substream_kind, substream in stream:
2498
self.records.append(
2499
(substream_kind, [record.key for record in substream]))
2500
return ['fake tokens'], ['fake missing keys']
2501
fake_real_sink = FakeRealSink()
2502
class FakeRealRepository:
2503
def _get_sink(self):
2504
return fake_real_sink
2505
def is_in_write_group(self):
2507
def refresh_data(self):
2509
repo._real_repository = FakeRealRepository()
2510
sink = repo._get_sink()
2511
fmt = repository.RepositoryFormat.get_default_format()
2512
stream = self.make_stream_with_inv_deltas(fmt)
2513
resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2514
# Every record from the first inventory delta should have been sent to
2516
expected_records = [
2517
('inventory-deltas', [('rev2',), ('rev3',)]),
2518
('texts', [('some-rev', 'some-file')])]
2519
self.assertEqual(expected_records, fake_real_sink.records)
2520
# The return values from the real sink's insert_stream are propagated
2521
# back to the original caller.
2522
self.assertEqual(['fake tokens'], resume_tokens)
2523
self.assertEqual(['fake missing keys'], missing_keys)
2524
self.assertFinished(client)
2526
def make_stream_with_inv_deltas(self, fmt):
2527
"""Make a simple stream with an inventory delta followed by more
2528
records and more substreams to test that all records and substreams
2529
from that point on are used.
2531
This sends, in order:
2532
* inventories substream: rev1, rev2, rev3. rev2 and rev3 are
2534
* texts substream: (some-rev, some-file)
2536
# Define a stream using generators so that it isn't rewindable.
2537
inv = inventory.Inventory(revision_id='rev1')
2538
inv.root.revision = 'rev1'
2539
def stream_with_inv_delta():
2540
yield ('inventories', inventories_substream())
2541
yield ('inventory-deltas', inventory_delta_substream())
2543
versionedfile.FulltextContentFactory(
2544
('some-rev', 'some-file'), (), None, 'content')])
2545
def inventories_substream():
2546
# An empty inventory fulltext. This will be streamed normally.
2547
text = fmt._serializer.write_inventory_to_string(inv)
2548
yield versionedfile.FulltextContentFactory(
2549
('rev1',), (), None, text)
2550
def inventory_delta_substream():
2551
# An inventory delta. This can't be streamed via this verb, so it
2552
# will trigger a fallback to VFS insert_stream.
2553
entry = inv.make_entry(
2554
'directory', 'newdir', inv.root.file_id, 'newdir-id')
2555
entry.revision = 'ghost'
2556
delta = [(None, 'newdir', 'newdir-id', entry)]
2557
serializer = inventory_delta.InventoryDeltaSerializer(
2558
versioned_root=True, tree_references=False)
2559
lines = serializer.delta_to_lines('rev1', 'rev2', delta)
2560
yield versionedfile.ChunkedContentFactory(
2561
('rev2',), (('rev1',)), None, lines)
2563
lines = serializer.delta_to_lines('rev1', 'rev3', delta)
2564
yield versionedfile.ChunkedContentFactory(
2565
('rev3',), (('rev1',)), None, lines)
2566
return stream_with_inv_delta()
2569
class TestRepositoryInsertStream_1_19(TestRepositoryInsertStreamBase):
2571
def test_unlocked_repo(self):
2572
transport_path = 'quack'
2573
repo, client = self.setup_fake_client_and_repository(transport_path)
2574
client.add_expected_call(
2575
'Repository.insert_stream_1.19', ('quack/', ''),
2577
client.add_expected_call(
2578
'Repository.insert_stream_1.19', ('quack/', ''),
2580
self.checkInsertEmptyStream(repo, client)
2582
def test_locked_repo_with_no_lock_token(self):
2583
transport_path = 'quack'
2584
repo, client = self.setup_fake_client_and_repository(transport_path)
2585
client.add_expected_call(
2586
'Repository.lock_write', ('quack/', ''),
2587
'success', ('ok', ''))
2588
client.add_expected_call(
2589
'Repository.insert_stream_1.19', ('quack/', ''),
2591
client.add_expected_call(
2592
'Repository.insert_stream_1.19', ('quack/', ''),
2595
self.checkInsertEmptyStream(repo, client)
2597
def test_locked_repo_with_lock_token(self):
2598
transport_path = 'quack'
2599
repo, client = self.setup_fake_client_and_repository(transport_path)
2600
client.add_expected_call(
2601
'Repository.lock_write', ('quack/', ''),
2602
'success', ('ok', 'a token'))
2603
client.add_expected_call(
2604
'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2606
client.add_expected_call(
2607
'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2610
self.checkInsertEmptyStream(repo, client)
2613
898
class TestRepositoryTarball(TestRemoteRepository):
2615
900
# This is a canned tarball reponse we can validate against
2664
951
src_repo.copy_content_into(dest_repo)
2667
class _StubRealPackRepository(object):
2669
def __init__(self, calls):
2671
self._pack_collection = _StubPackCollection(calls)
2673
def is_in_write_group(self):
2676
def refresh_data(self):
2677
self.calls.append(('pack collection reload_pack_names',))
2680
class _StubPackCollection(object):
2682
def __init__(self, calls):
2686
self.calls.append(('pack collection autopack',))
2689
class TestRemotePackRepositoryAutoPack(TestRemoteRepository):
2690
"""Tests for RemoteRepository.autopack implementation."""
2693
"""When the server returns 'ok' and there's no _real_repository, then
2694
nothing else happens: the autopack method is done.
2696
transport_path = 'quack'
2697
repo, client = self.setup_fake_client_and_repository(transport_path)
2698
client.add_expected_call(
2699
'PackRepository.autopack', ('quack/',), 'success', ('ok',))
2701
self.assertFinished(client)
2703
def test_ok_with_real_repo(self):
2704
"""When the server returns 'ok' and there is a _real_repository, then
2705
the _real_repository's reload_pack_name's method will be called.
2707
transport_path = 'quack'
2708
repo, client = self.setup_fake_client_and_repository(transport_path)
2709
client.add_expected_call(
2710
'PackRepository.autopack', ('quack/',),
2712
repo._real_repository = _StubRealPackRepository(client._calls)
2715
[('call', 'PackRepository.autopack', ('quack/',)),
2716
('pack collection reload_pack_names',)],
954
class TestRepositoryStreamKnitData(TestRemoteRepository):
956
def make_pack_file(self, records):
957
pack_file = StringIO()
958
pack_writer = pack.ContainerWriter(pack_file.write)
960
for bytes, names in records:
961
pack_writer.add_bytes_record(bytes, names)
966
def make_pack_stream(self, records):
967
pack_serialiser = pack.ContainerSerialiser()
968
yield pack_serialiser.begin()
969
for bytes, names in records:
970
yield pack_serialiser.bytes_record(bytes, names)
971
yield pack_serialiser.end()
973
def test_bad_pack_from_server(self):
974
"""A response with invalid data (e.g. it has a record with multiple
975
names) triggers an exception.
977
Not all possible errors will be caught at this stage, but obviously
978
malformed data should be.
980
record = ('bytes', [('name1',), ('name2',)])
981
pack_stream = self.make_pack_stream([record])
982
responses = [(('ok',), pack_stream), ]
983
transport_path = 'quack'
984
repo, client = self.setup_fake_client_and_repository(
985
responses, transport_path)
986
search = graph.SearchResult(set(['revid']), set(), 1, set(['revid']))
987
stream = repo.get_data_stream_for_search(search)
988
self.assertRaises(errors.SmartProtocolError, list, stream)
2719
990
def test_backwards_compatibility(self):
2720
"""If the server does not recognise the PackRepository.autopack verb,
2721
fallback to the real_repository's implementation.
2723
transport_path = 'quack'
2724
repo, client = self.setup_fake_client_and_repository(transport_path)
2725
client.add_unknown_method_response('PackRepository.autopack')
2726
def stub_ensure_real():
2727
client._calls.append(('_ensure_real',))
2728
repo._real_repository = _StubRealPackRepository(client._calls)
2729
repo._ensure_real = stub_ensure_real
2732
[('call', 'PackRepository.autopack', ('quack/',)),
2734
('pack collection autopack',)],
2738
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
2739
"""Base class for unit tests for bzrlib.remote._translate_error."""
2741
def translateTuple(self, error_tuple, **context):
2742
"""Call _translate_error with an ErrorFromSmartServer built from the
2745
:param error_tuple: A tuple of a smart server response, as would be
2746
passed to an ErrorFromSmartServer.
2747
:kwargs context: context items to call _translate_error with.
2749
:returns: The error raised by _translate_error.
2751
# Raise the ErrorFromSmartServer before passing it as an argument,
2752
# because _translate_error may need to re-raise it with a bare 'raise'
2754
server_error = errors.ErrorFromSmartServer(error_tuple)
2755
translated_error = self.translateErrorFromSmartServer(
2756
server_error, **context)
2757
return translated_error
2759
def translateErrorFromSmartServer(self, error_object, **context):
2760
"""Like translateTuple, but takes an already constructed
2761
ErrorFromSmartServer rather than a tuple.
2765
except errors.ErrorFromSmartServer, server_error:
2766
translated_error = self.assertRaises(
2767
errors.BzrError, remote._translate_error, server_error,
2769
return translated_error
2772
class TestErrorTranslationSuccess(TestErrorTranslationBase):
2773
"""Unit tests for bzrlib.remote._translate_error.
2775
Given an ErrorFromSmartServer (which has an error tuple from a smart
2776
server) and some context, _translate_error raises more specific errors from
2779
This test case covers the cases where _translate_error succeeds in
2780
translating an ErrorFromSmartServer to something better. See
2781
TestErrorTranslationRobustness for other cases.
2784
def test_NoSuchRevision(self):
2785
branch = self.make_branch('')
2787
translated_error = self.translateTuple(
2788
('NoSuchRevision', revid), branch=branch)
2789
expected_error = errors.NoSuchRevision(branch, revid)
2790
self.assertEqual(expected_error, translated_error)
2792
def test_nosuchrevision(self):
2793
repository = self.make_repository('')
2795
translated_error = self.translateTuple(
2796
('nosuchrevision', revid), repository=repository)
2797
expected_error = errors.NoSuchRevision(repository, revid)
2798
self.assertEqual(expected_error, translated_error)
2800
def test_nobranch(self):
2801
bzrdir = self.make_bzrdir('')
2802
translated_error = self.translateTuple(('nobranch',), bzrdir=bzrdir)
2803
expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
2804
self.assertEqual(expected_error, translated_error)
2806
def test_nobranch_one_arg(self):
2807
bzrdir = self.make_bzrdir('')
2808
translated_error = self.translateTuple(
2809
('nobranch', 'extra detail'), bzrdir=bzrdir)
2810
expected_error = errors.NotBranchError(
2811
path=bzrdir.root_transport.base,
2812
detail='extra detail')
2813
self.assertEqual(expected_error, translated_error)
2815
def test_LockContention(self):
2816
translated_error = self.translateTuple(('LockContention',))
2817
expected_error = errors.LockContention('(remote lock)')
2818
self.assertEqual(expected_error, translated_error)
2820
def test_UnlockableTransport(self):
2821
bzrdir = self.make_bzrdir('')
2822
translated_error = self.translateTuple(
2823
('UnlockableTransport',), bzrdir=bzrdir)
2824
expected_error = errors.UnlockableTransport(bzrdir.root_transport)
2825
self.assertEqual(expected_error, translated_error)
2827
def test_LockFailed(self):
2828
lock = 'str() of a server lock'
2829
why = 'str() of why'
2830
translated_error = self.translateTuple(('LockFailed', lock, why))
2831
expected_error = errors.LockFailed(lock, why)
2832
self.assertEqual(expected_error, translated_error)
2834
def test_TokenMismatch(self):
2835
token = 'a lock token'
2836
translated_error = self.translateTuple(('TokenMismatch',), token=token)
2837
expected_error = errors.TokenMismatch(token, '(remote token)')
2838
self.assertEqual(expected_error, translated_error)
2840
def test_Diverged(self):
2841
branch = self.make_branch('a')
2842
other_branch = self.make_branch('b')
2843
translated_error = self.translateTuple(
2844
('Diverged',), branch=branch, other_branch=other_branch)
2845
expected_error = errors.DivergedBranches(branch, other_branch)
2846
self.assertEqual(expected_error, translated_error)
2848
def test_ReadError_no_args(self):
2850
translated_error = self.translateTuple(('ReadError',), path=path)
2851
expected_error = errors.ReadError(path)
2852
self.assertEqual(expected_error, translated_error)
2854
def test_ReadError(self):
2856
translated_error = self.translateTuple(('ReadError', path))
2857
expected_error = errors.ReadError(path)
2858
self.assertEqual(expected_error, translated_error)
2860
def test_IncompatibleRepositories(self):
2861
translated_error = self.translateTuple(('IncompatibleRepositories',
2862
"repo1", "repo2", "details here"))
2863
expected_error = errors.IncompatibleRepositories("repo1", "repo2",
2865
self.assertEqual(expected_error, translated_error)
2867
def test_PermissionDenied_no_args(self):
2869
translated_error = self.translateTuple(('PermissionDenied',), path=path)
2870
expected_error = errors.PermissionDenied(path)
2871
self.assertEqual(expected_error, translated_error)
2873
def test_PermissionDenied_one_arg(self):
2875
translated_error = self.translateTuple(('PermissionDenied', path))
2876
expected_error = errors.PermissionDenied(path)
2877
self.assertEqual(expected_error, translated_error)
2879
def test_PermissionDenied_one_arg_and_context(self):
2880
"""Given a choice between a path from the local context and a path on
2881
the wire, _translate_error prefers the path from the local context.
2883
local_path = 'local path'
2884
remote_path = 'remote path'
2885
translated_error = self.translateTuple(
2886
('PermissionDenied', remote_path), path=local_path)
2887
expected_error = errors.PermissionDenied(local_path)
2888
self.assertEqual(expected_error, translated_error)
2890
def test_PermissionDenied_two_args(self):
2892
extra = 'a string with extra info'
2893
translated_error = self.translateTuple(
2894
('PermissionDenied', path, extra))
2895
expected_error = errors.PermissionDenied(path, extra)
2896
self.assertEqual(expected_error, translated_error)
2899
class TestErrorTranslationRobustness(TestErrorTranslationBase):
2900
"""Unit tests for bzrlib.remote._translate_error's robustness.
2902
TestErrorTranslationSuccess is for cases where _translate_error can
2903
translate successfully. This class about how _translate_err behaves when
2904
it fails to translate: it re-raises the original error.
2907
def test_unrecognised_server_error(self):
2908
"""If the error code from the server is not recognised, the original
2909
ErrorFromSmartServer is propagated unmodified.
2911
error_tuple = ('An unknown error tuple',)
2912
server_error = errors.ErrorFromSmartServer(error_tuple)
2913
translated_error = self.translateErrorFromSmartServer(server_error)
2914
expected_error = errors.UnknownErrorFromSmartServer(server_error)
2915
self.assertEqual(expected_error, translated_error)
2917
def test_context_missing_a_key(self):
2918
"""In case of a bug in the client, or perhaps an unexpected response
2919
from a server, _translate_error returns the original error tuple from
2920
the server and mutters a warning.
2922
# To translate a NoSuchRevision error _translate_error needs a 'branch'
2923
# in the context dict. So let's give it an empty context dict instead
2924
# to exercise its error recovery.
2926
error_tuple = ('NoSuchRevision', 'revid')
2927
server_error = errors.ErrorFromSmartServer(error_tuple)
2928
translated_error = self.translateErrorFromSmartServer(server_error)
2929
self.assertEqual(server_error, translated_error)
2930
# In addition to re-raising ErrorFromSmartServer, some debug info has
2931
# been muttered to the log file for developer to look at.
2932
self.assertContainsRe(
2934
"Missing key 'branch' in context")
2936
def test_path_missing(self):
2937
"""Some translations (PermissionDenied, ReadError) can determine the
2938
'path' variable from either the wire or the local context. If neither
2939
has it, then an error is raised.
2941
error_tuple = ('ReadError',)
2942
server_error = errors.ErrorFromSmartServer(error_tuple)
2943
translated_error = self.translateErrorFromSmartServer(server_error)
2944
self.assertEqual(server_error, translated_error)
2945
# In addition to re-raising ErrorFromSmartServer, some debug info has
2946
# been muttered to the log file for developer to look at.
2947
self.assertContainsRe(self.get_log(), "Missing key 'path' in context")
2950
class TestStacking(tests.TestCaseWithTransport):
2951
"""Tests for operations on stacked remote repositories.
2953
The underlying format type must support stacking.
2956
def test_access_stacked_remote(self):
2957
# based on <http://launchpad.net/bugs/261315>
2958
# make a branch stacked on another repository containing an empty
2959
# revision, then open it over hpss - we should be able to see that
2961
base_transport = self.get_transport()
2962
base_builder = self.make_branch_builder('base', format='1.9')
2963
base_builder.start_series()
2964
base_revid = base_builder.build_snapshot('rev-id', None,
2965
[('add', ('', None, 'directory', None))],
2967
base_builder.finish_series()
2968
stacked_branch = self.make_branch('stacked', format='1.9')
2969
stacked_branch.set_stacked_on_url('../base')
2970
# start a server looking at this
2971
smart_server = test_server.SmartTCPServer_for_testing()
2972
self.start_server(smart_server)
2973
remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
2974
# can get its branch and repository
2975
remote_branch = remote_bzrdir.open_branch()
2976
remote_repo = remote_branch.repository
2977
remote_repo.lock_read()
2979
# it should have an appropriate fallback repository, which should also
2980
# be a RemoteRepository
2981
self.assertLength(1, remote_repo._fallback_repositories)
2982
self.assertIsInstance(remote_repo._fallback_repositories[0],
2984
# and it has the revision committed to the underlying repository;
2985
# these have varying implementations so we try several of them
2986
self.assertTrue(remote_repo.has_revisions([base_revid]))
2987
self.assertTrue(remote_repo.has_revision(base_revid))
2988
self.assertEqual(remote_repo.get_revision(base_revid).message,
2991
remote_repo.unlock()
2993
def prepare_stacked_remote_branch(self):
2994
"""Get stacked_upon and stacked branches with content in each."""
2995
self.setup_smart_server_with_call_log()
2996
tree1 = self.make_branch_and_tree('tree1', format='1.9')
2997
tree1.commit('rev1', rev_id='rev1')
2998
tree2 = tree1.branch.bzrdir.sprout('tree2', stacked=True
2999
).open_workingtree()
3000
local_tree = tree2.branch.create_checkout('local')
3001
local_tree.commit('local changes make me feel good.')
3002
branch2 = Branch.open(self.get_url('tree2'))
3004
self.addCleanup(branch2.unlock)
3005
return tree1.branch, branch2
3007
def test_stacked_get_parent_map(self):
3008
# the public implementation of get_parent_map obeys stacking
3009
_, branch = self.prepare_stacked_remote_branch()
3010
repo = branch.repository
3011
self.assertEqual(['rev1'], repo.get_parent_map(['rev1']).keys())
3013
def test_unstacked_get_parent_map(self):
3014
# _unstacked_provider.get_parent_map ignores stacking
3015
_, branch = self.prepare_stacked_remote_branch()
3016
provider = branch.repository._unstacked_provider
3017
self.assertEqual([], provider.get_parent_map(['rev1']).keys())
3019
def fetch_stream_to_rev_order(self, stream):
3021
for kind, substream in stream:
3022
if not kind == 'revisions':
3025
for content in substream:
3026
result.append(content.key[-1])
3029
def get_ordered_revs(self, format, order, branch_factory=None):
3030
"""Get a list of the revisions in a stream to format format.
3032
:param format: The format of the target.
3033
:param order: the order that target should have requested.
3034
:param branch_factory: A callable to create a trunk and stacked branch
3035
to fetch from. If none, self.prepare_stacked_remote_branch is used.
3036
:result: The revision ids in the stream, in the order seen,
3037
the topological order of revisions in the source.
3039
unordered_format = bzrdir.format_registry.get(format)()
3040
target_repository_format = unordered_format.repository_format
3042
self.assertEqual(order, target_repository_format._fetch_order)
3043
if branch_factory is None:
3044
branch_factory = self.prepare_stacked_remote_branch
3045
_, stacked = branch_factory()
3046
source = stacked.repository._get_source(target_repository_format)
3047
tip = stacked.last_revision()
3048
revs = stacked.repository.get_ancestry(tip)
3049
search = graph.PendingAncestryResult([tip], stacked.repository)
3050
self.reset_smart_call_log()
3051
stream = source.get_stream(search)
3054
# We trust that if a revision is in the stream the rest of the new
3055
# content for it is too, as per our main fetch tests; here we are
3056
# checking that the revisions are actually included at all, and their
3058
return self.fetch_stream_to_rev_order(stream), revs
3060
def test_stacked_get_stream_unordered(self):
3061
# Repository._get_source.get_stream() from a stacked repository with
3062
# unordered yields the full data from both stacked and stacked upon
3064
rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered')
3065
self.assertEqual(set(expected_revs), set(rev_ord))
3066
# Getting unordered results should have made a streaming data request
3067
# from the server, then one from the backing branch.
3068
self.assertLength(2, self.hpss_calls)
3070
def test_stacked_on_stacked_get_stream_unordered(self):
3071
# Repository._get_source.get_stream() from a stacked repository which
3072
# is itself stacked yields the full data from all three sources.
3073
def make_stacked_stacked():
3074
_, stacked = self.prepare_stacked_remote_branch()
3075
tree = stacked.bzrdir.sprout('tree3', stacked=True
3076
).open_workingtree()
3077
local_tree = tree.branch.create_checkout('local-tree3')
3078
local_tree.commit('more local changes are better')
3079
branch = Branch.open(self.get_url('tree3'))
3081
self.addCleanup(branch.unlock)
3083
rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
3084
branch_factory=make_stacked_stacked)
3085
self.assertEqual(set(expected_revs), set(rev_ord))
3086
# Getting unordered results should have made a streaming data request
3087
# from the server, and one from each backing repo
3088
self.assertLength(3, self.hpss_calls)
3090
def test_stacked_get_stream_topological(self):
3091
# Repository._get_source.get_stream() from a stacked repository with
3092
# topological sorting yields the full data from both stacked and
3093
# stacked upon sources in topological order.
3094
rev_ord, expected_revs = self.get_ordered_revs('knit', 'topological')
3095
self.assertEqual(expected_revs, rev_ord)
3096
# Getting topological sort requires VFS calls still - one of which is
3097
# pushing up from the bound branch.
3098
self.assertLength(13, self.hpss_calls)
3100
def test_stacked_get_stream_groupcompress(self):
3101
# Repository._get_source.get_stream() from a stacked repository with
3102
# groupcompress sorting yields the full data from both stacked and
3103
# stacked upon sources in groupcompress order.
3104
raise tests.TestSkipped('No groupcompress ordered format available')
3105
rev_ord, expected_revs = self.get_ordered_revs('dev5', 'groupcompress')
3106
self.assertEqual(expected_revs, reversed(rev_ord))
3107
# Getting unordered results should have made a streaming data request
3108
# from the backing branch, and one from the stacked on branch.
3109
self.assertLength(2, self.hpss_calls)
3111
def test_stacked_pull_more_than_stacking_has_bug_360791(self):
3112
# When pulling some fixed amount of content that is more than the
3113
# source has (because some is coming from a fallback branch, no error
3114
# should be received. This was reported as bug 360791.
3115
# Need three branches: a trunk, a stacked branch, and a preexisting
3116
# branch pulling content from stacked and trunk.
3117
self.setup_smart_server_with_call_log()
3118
trunk = self.make_branch_and_tree('trunk', format="1.9-rich-root")
3119
r1 = trunk.commit('start')
3120
stacked_branch = trunk.branch.create_clone_on_transport(
3121
self.get_transport('stacked'), stacked_on=trunk.branch.base)
3122
local = self.make_branch('local', format='1.9-rich-root')
3123
local.repository.fetch(stacked_branch.repository,
3124
stacked_branch.last_revision())
3127
class TestRemoteBranchEffort(tests.TestCaseWithTransport):
3130
super(TestRemoteBranchEffort, self).setUp()
3131
# Create a smart server that publishes whatever the backing VFS server
3133
self.smart_server = test_server.SmartTCPServer_for_testing()
3134
self.start_server(self.smart_server, self.get_server())
3135
# Log all HPSS calls into self.hpss_calls.
3136
_SmartClient.hooks.install_named_hook(
3137
'call', self.capture_hpss_call, None)
3138
self.hpss_calls = []
3140
def capture_hpss_call(self, params):
3141
self.hpss_calls.append(params.method)
3143
def test_copy_content_into_avoids_revision_history(self):
3144
local = self.make_branch('local')
3145
remote_backing_tree = self.make_branch_and_tree('remote')
3146
remote_backing_tree.commit("Commit.")
3147
remote_branch_url = self.smart_server.get_url() + 'remote'
3148
remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3149
local.repository.fetch(remote_branch.repository)
3150
self.hpss_calls = []
3151
remote_branch.copy_content_into(local)
3152
self.assertFalse('Branch.revision_history' in self.hpss_calls)
991
"""If the server doesn't recognise this request, fallback to VFS."""
993
"Generic bzr smart protocol error: "
994
"bad request 'Repository.stream_revisions_chunked'")
996
(('error', error_msg), '')]
997
repo, client = self.setup_fake_client_and_repository(
999
self.mock_called = False
1000
repo._real_repository = MockRealRepository(self)
1001
search = graph.SearchResult(set(['revid']), set(), 1, set(['revid']))
1002
repo.get_data_stream_for_search(search)
1003
self.assertTrue(self.mock_called)
1004
self.failIf(client.expecting_body,
1005
"The protocol has been left in an unclean state that will cause "
1006
"TooManyConcurrentRequests errors.")
1009
class MockRealRepository(object):
1010
"""Helper class for TestRepositoryStreamKnitData.test_unknown_method."""
1012
def __init__(self, test):
1015
def get_data_stream_for_search(self, search):
1016
self.test.assertEqual(set(['revid']), search.get_keys())
1017
self.test.mock_called = True
added
removed
bzrlib/tests/test_remote.py
