135
102
b = BzrDir.open_from_transport(self.transport).open_branch()
136
103
self.assertStartsWith(str(b), 'RemoteBranch(')
138
def test_remote_bzrdir_repr(self):
139
b = BzrDir.open_from_transport(self.transport)
140
self.assertStartsWith(str(b), 'RemoteBzrDir(')
142
def test_remote_branch_format_supports_stacking(self):
144
self.make_branch('unstackable', format='pack-0.92')
145
b = BzrDir.open_from_transport(t.clone('unstackable')).open_branch()
146
self.assertFalse(b._format.supports_stacking())
147
self.make_branch('stackable', format='1.9')
148
b = BzrDir.open_from_transport(t.clone('stackable')).open_branch()
149
self.assertTrue(b._format.supports_stacking())
151
def test_remote_repo_format_supports_external_references(self):
153
bd = self.make_bzrdir('unstackable', format='pack-0.92')
154
r = bd.create_repository()
155
self.assertFalse(r._format.supports_external_lookups)
156
r = BzrDir.open_from_transport(t.clone('unstackable')).open_repository()
157
self.assertFalse(r._format.supports_external_lookups)
158
bd = self.make_bzrdir('stackable', format='1.9')
159
r = bd.create_repository()
160
self.assertTrue(r._format.supports_external_lookups)
161
r = BzrDir.open_from_transport(t.clone('stackable')).open_repository()
162
self.assertTrue(r._format.supports_external_lookups)
164
def test_remote_branch_set_append_revisions_only(self):
165
# Make a format 1.9 branch, which supports append_revisions_only
166
branch = self.make_branch('branch', format='1.9')
167
config = branch.get_config()
168
branch.set_append_revisions_only(True)
170
'True', config.get_user_option('append_revisions_only'))
171
branch.set_append_revisions_only(False)
173
'False', config.get_user_option('append_revisions_only'))
175
def test_remote_branch_set_append_revisions_only_upgrade_reqd(self):
176
branch = self.make_branch('branch', format='knit')
177
config = branch.get_config()
179
errors.UpgradeRequired, branch.set_append_revisions_only, True)
182
106
class FakeProtocol(object):
183
107
"""Lookalike SmartClientRequestProtocolOne allowing body reading tests."""
185
def __init__(self, body, fake_client):
187
self._body_buffer = None
188
self._fake_client = fake_client
109
def __init__(self, body):
110
self._body_buffer = StringIO(body)
190
112
def read_body_bytes(self, count=-1):
191
if self._body_buffer is None:
192
self._body_buffer = StringIO(self.body)
193
bytes = self._body_buffer.read(count)
194
if self._body_buffer.tell() == len(self._body_buffer.getvalue()):
195
self._fake_client.expecting_body = False
198
def cancel_read_body(self):
199
self._fake_client.expecting_body = False
201
def read_streamed_body(self):
113
return self._body_buffer.read(count)
205
116
class FakeClient(_SmartClient):
206
117
"""Lookalike for _SmartClient allowing testing."""
119
def __init__(self, responses):
120
# We don't call the super init because there is no medium.
121
"""create a FakeClient.
208
def __init__(self, fake_medium_base='fake base'):
209
"""Create a FakeClient."""
123
:param respones: A list of response-tuple, body-data pairs to be sent
126
self.responses = responses
212
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,))
275
129
def call(self, method, *args):
276
self._check_call(method, args)
277
130
self._calls.append(('call', method, args))
278
return self._get_next_response()[1]
131
return self.responses.pop(0)[0]
280
133
def call_expecting_body(self, method, *args):
281
self._check_call(method, args)
282
134
self._calls.append(('call_expecting_body', method, args))
283
result = self._get_next_response()
284
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)
293
def call_with_body_bytes_expecting_body(self, method, args, body):
294
self._check_call(method, args)
295
self._calls.append(('call_with_body_bytes_expecting_body', method,
297
result = self._get_next_response()
298
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)
318
self._client_calls = client_calls
320
def disconnect(self):
321
self._client_calls.append(('disconnect medium',))
324
class TestVfsHas(tests.TestCase):
326
def test_unicode_path(self):
327
client = FakeClient('/')
328
client.add_success_response('yes',)
329
transport = RemoteTransport('bzr://localhost/', _client=client)
330
filename = u'/hell\u00d8'.encode('utf8')
331
result = transport.has(filename)
333
[('call', 'has', (filename,))],
335
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."""
356
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.
361
client_medium = medium.SmartClientMedium(client_base)
362
transport = get_transport(transport_base)
363
result = client_medium.remote_path_from_transport(transport)
364
self.assertEqual(expected, result)
366
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.
370
self.assertRemotePath('xyz/', 'bzr://host/path', 'bzr://host/xyz')
371
self.assertRemotePath(
372
'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
def test_remote_path_from_transport_http(self):
387
"""Remote paths for HTTP transports are calculated differently to other
388
transports. They are just relative to the client base, not the root
389
directory of the host.
391
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
# You cannot call _remember_remote_is_before with a larger value.
423
AssertionError, client_medium._remember_remote_is_before, (1, 9))
426
class TestBzrDirCloningMetaDir(TestRemote):
428
def test_backwards_compat(self):
429
self.setup_smart_server_with_call_log()
430
a_dir = self.make_bzrdir('.')
431
self.reset_smart_call_log()
432
verb = 'BzrDir.cloning_metadir'
433
self.disable_verb(verb)
434
format = a_dir.cloning_metadir()
435
call_count = len([call for call in self.hpss_calls if
436
call.call.method == verb])
437
self.assertEqual(1, call_count)
439
def test_branch_reference(self):
440
transport = self.get_transport('quack')
441
referenced = self.make_branch('referenced')
442
expected = referenced.bzrdir.cloning_metadir()
443
client = FakeClient(transport.base)
444
client.add_expected_call(
445
'BzrDir.cloning_metadir', ('quack/', 'False'),
446
'error', ('BranchReference',)),
447
client.add_expected_call(
448
'BzrDir.open_branchV3', ('quack/',),
449
'success', ('ref', self.get_url('referenced'))),
450
a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
452
result = a_bzrdir.cloning_metadir()
453
# We should have got a control dir matching the referenced branch.
454
self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
455
self.assertEqual(expected._repository_format, result._repository_format)
456
self.assertEqual(expected._branch_format, result._branch_format)
457
self.assertFinished(client)
459
def test_current_server(self):
460
transport = self.get_transport('.')
461
transport = transport.clone('quack')
462
self.make_bzrdir('quack')
463
client = FakeClient(transport.base)
464
reference_bzrdir_format = bzrdir.format_registry.get('default')()
465
control_name = reference_bzrdir_format.network_name()
466
client.add_expected_call(
467
'BzrDir.cloning_metadir', ('quack/', 'False'),
468
'success', (control_name, '', ('branch', ''))),
469
a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
471
result = a_bzrdir.cloning_metadir()
472
# We should have got a reference control dir with default branch and
473
# repository formats.
474
# This pokes a little, just to be sure.
475
self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
476
self.assertEqual(None, result._repository_format)
477
self.assertEqual(None, result._branch_format)
478
self.assertFinished(client)
481
class TestBzrDirOpen(TestRemote):
483
def make_fake_client_and_transport(self, path='quack'):
484
transport = MemoryTransport()
485
transport.mkdir(path)
486
transport = transport.clone(path)
487
client = FakeClient(transport.base)
488
return client, transport
490
def test_absent(self):
491
client, transport = self.make_fake_client_and_transport()
492
client.add_expected_call(
493
'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
494
self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
495
remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
496
self.assertFinished(client)
498
def test_present_without_workingtree(self):
499
client, transport = self.make_fake_client_and_transport()
500
client.add_expected_call(
501
'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
502
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
503
_client=client, _force_probe=True)
504
self.assertIsInstance(bd, RemoteBzrDir)
505
self.assertFalse(bd.has_workingtree())
506
self.assertRaises(errors.NoWorkingTree, bd.open_workingtree)
507
self.assertFinished(client)
509
def test_present_with_workingtree(self):
510
client, transport = self.make_fake_client_and_transport()
511
client.add_expected_call(
512
'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
513
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
514
_client=client, _force_probe=True)
515
self.assertIsInstance(bd, RemoteBzrDir)
516
self.assertTrue(bd.has_workingtree())
517
self.assertRaises(errors.NotLocalUrl, bd.open_workingtree)
518
self.assertFinished(client)
520
def test_backwards_compat(self):
521
client, transport = self.make_fake_client_and_transport()
522
client.add_expected_call(
523
'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
524
client.add_expected_call(
525
'BzrDir.open', ('quack/',), 'success', ('yes',))
526
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
527
_client=client, _force_probe=True)
528
self.assertIsInstance(bd, RemoteBzrDir)
529
self.assertFinished(client)
532
class TestBzrDirOpenBranch(TestRemote):
534
def test_backwards_compat(self):
535
self.setup_smart_server_with_call_log()
536
self.make_branch('.')
537
a_dir = BzrDir.open(self.get_url('.'))
538
self.reset_smart_call_log()
539
verb = 'BzrDir.open_branchV3'
540
self.disable_verb(verb)
541
format = a_dir.open_branch()
542
call_count = len([call for call in self.hpss_calls if
543
call.call.method == verb])
544
self.assertEqual(1, call_count)
135
result = self.responses.pop(0)
136
return result[0], FakeProtocol(result[1])
139
class TestBzrDirOpenBranch(tests.TestCase):
546
141
def test_branch_present(self):
547
reference_format = self.get_repo_format()
548
network_name = reference_format.network_name()
549
branch_network_name = self.get_branch_format().network_name()
142
client = FakeClient([(('ok', ''), ), (('ok', '', 'no', 'no'), )])
550
143
transport = MemoryTransport()
551
144
transport.mkdir('quack')
552
145
transport = transport.clone('quack')
553
client = FakeClient(transport.base)
554
client.add_expected_call(
555
'BzrDir.open_branchV3', ('quack/',),
556
'success', ('branch', branch_network_name))
557
client.add_expected_call(
558
'BzrDir.find_repositoryV3', ('quack/',),
559
'success', ('ok', '', 'no', 'no', 'no', network_name))
560
client.add_expected_call(
561
'Branch.get_stacked_on_url', ('quack/',),
562
'error', ('NotStacked',))
563
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
146
bzrdir = RemoteBzrDir(transport, _client=client)
565
147
result = bzrdir.open_branch()
149
[('call', 'BzrDir.open_branch', ('///quack/',)),
150
('call', 'BzrDir.find_repository', ('///quack/',))],
566
152
self.assertIsInstance(result, RemoteBranch)
567
153
self.assertEqual(bzrdir, result.bzrdir)
568
self.assertFinished(client)
570
155
def test_branch_missing(self):
156
client = FakeClient([(('nobranch',), )])
571
157
transport = MemoryTransport()
572
158
transport.mkdir('quack')
573
159
transport = transport.clone('quack')
574
client = FakeClient(transport.base)
575
client.add_error_response('nobranch')
576
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
160
bzrdir = RemoteBzrDir(transport, _client=client)
578
161
self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
579
162
self.assertEqual(
580
[('call', 'BzrDir.open_branchV3', ('quack/',))],
163
[('call', 'BzrDir.open_branch', ('///quack/',))],
583
def test__get_tree_branch(self):
584
# _get_tree_branch is a form of open_branch, but it should only ask for
585
# branch opening, not any other network requests.
588
calls.append("Called")
590
transport = MemoryTransport()
591
# no requests on the network - catches other api calls being made.
592
client = FakeClient(transport.base)
593
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
595
# patch the open_branch call to record that it was called.
596
bzrdir.open_branch = open_branch
597
self.assertEqual((None, "a-branch"), bzrdir._get_tree_branch())
598
self.assertEqual(["Called"], calls)
599
self.assertEqual([], client._calls)
601
def test_url_quoting_of_path(self):
602
# Relpaths on the wire should not be URL-escaped. So "~" should be
603
# transmitted as "~", not "%7E".
604
transport = RemoteTCPTransport('bzr://localhost/~hello/')
605
client = FakeClient(transport.base)
606
reference_format = self.get_repo_format()
607
network_name = reference_format.network_name()
608
branch_network_name = self.get_branch_format().network_name()
609
client.add_expected_call(
610
'BzrDir.open_branchV3', ('~hello/',),
611
'success', ('branch', branch_network_name))
612
client.add_expected_call(
613
'BzrDir.find_repositoryV3', ('~hello/',),
614
'success', ('ok', '', 'no', 'no', 'no', network_name))
615
client.add_expected_call(
616
'Branch.get_stacked_on_url', ('~hello/',),
617
'error', ('NotStacked',))
618
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
620
result = bzrdir.open_branch()
621
self.assertFinished(client)
623
def check_open_repository(self, rich_root, subtrees, external_lookup='no'):
624
reference_format = self.get_repo_format()
625
network_name = reference_format.network_name()
626
transport = MemoryTransport()
627
transport.mkdir('quack')
628
transport = transport.clone('quack')
166
def check_open_repository(self, rich_root, subtrees):
630
168
rich_response = 'yes'
664
200
RemoteBzrDirFormat.probe_transport, OldServerTransport())
667
class TestBzrDirCreateBranch(TestRemote):
669
def test_backwards_compat(self):
670
self.setup_smart_server_with_call_log()
671
repo = self.make_repository('.')
672
self.reset_smart_call_log()
673
self.disable_verb('BzrDir.create_branch')
674
branch = repo.bzrdir.create_branch()
675
create_branch_call_count = len([call for call in self.hpss_calls if
676
call.call.method == 'BzrDir.create_branch'])
677
self.assertEqual(1, create_branch_call_count)
679
def test_current_server(self):
680
transport = self.get_transport('.')
681
transport = transport.clone('quack')
682
self.make_repository('quack')
683
client = FakeClient(transport.base)
684
reference_bzrdir_format = bzrdir.format_registry.get('default')()
685
reference_format = reference_bzrdir_format.get_branch_format()
686
network_name = reference_format.network_name()
687
reference_repo_fmt = reference_bzrdir_format.repository_format
688
reference_repo_name = reference_repo_fmt.network_name()
689
client.add_expected_call(
690
'BzrDir.create_branch', ('quack/', network_name),
691
'success', ('ok', network_name, '', 'no', 'no', 'yes',
692
reference_repo_name))
693
a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
695
branch = a_bzrdir.create_branch()
696
# We should have got a remote branch
697
self.assertIsInstance(branch, remote.RemoteBranch)
698
# its format should have the settings from the response
699
format = branch._format
700
self.assertEqual(network_name, format.network_name())
703
class TestBzrDirCreateRepository(TestRemote):
705
def test_backwards_compat(self):
706
self.setup_smart_server_with_call_log()
707
bzrdir = self.make_bzrdir('.')
708
self.reset_smart_call_log()
709
self.disable_verb('BzrDir.create_repository')
710
repo = bzrdir.create_repository()
711
create_repo_call_count = len([call for call in self.hpss_calls if
712
call.call.method == 'BzrDir.create_repository'])
713
self.assertEqual(1, create_repo_call_count)
715
def test_current_server(self):
716
transport = self.get_transport('.')
717
transport = transport.clone('quack')
718
self.make_bzrdir('quack')
719
client = FakeClient(transport.base)
720
reference_bzrdir_format = bzrdir.format_registry.get('default')()
721
reference_format = reference_bzrdir_format.repository_format
722
network_name = reference_format.network_name()
723
client.add_expected_call(
724
'BzrDir.create_repository', ('quack/',
725
'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
727
'success', ('ok', 'yes', 'yes', 'yes', network_name))
728
a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
730
repo = a_bzrdir.create_repository()
731
# We should have got a remote repository
732
self.assertIsInstance(repo, remote.RemoteRepository)
733
# its format should have the settings from the response
734
format = repo._format
735
self.assertTrue(format.rich_root_data)
736
self.assertTrue(format.supports_tree_reference)
737
self.assertTrue(format.supports_external_lookups)
738
self.assertEqual(network_name, format.network_name())
741
class TestBzrDirOpenRepository(TestRemote):
743
def test_backwards_compat_1_2_3(self):
744
# fallback all the way to the first version.
745
reference_format = self.get_repo_format()
746
network_name = reference_format.network_name()
747
server_url = 'bzr://example.com/'
748
self.permit_url(server_url)
749
client = FakeClient(server_url)
750
client.add_unknown_method_response('BzrDir.find_repositoryV3')
751
client.add_unknown_method_response('BzrDir.find_repositoryV2')
752
client.add_success_response('ok', '', 'no', 'no')
753
# A real repository instance will be created to determine the network
755
client.add_success_response_with_body(
756
"Bazaar-NG meta directory, format 1\n", 'ok')
757
client.add_success_response_with_body(
758
reference_format.get_format_string(), 'ok')
759
# PackRepository wants to do a stat
760
client.add_success_response('stat', '0', '65535')
761
remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
763
bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
765
repo = bzrdir.open_repository()
767
[('call', 'BzrDir.find_repositoryV3', ('quack/',)),
768
('call', 'BzrDir.find_repositoryV2', ('quack/',)),
769
('call', 'BzrDir.find_repository', ('quack/',)),
770
('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
771
('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
772
('call', 'stat', ('/quack/.bzr/repository',)),
775
self.assertEqual(network_name, repo._format.network_name())
777
def test_backwards_compat_2(self):
778
# fallback to find_repositoryV2
779
reference_format = self.get_repo_format()
780
network_name = reference_format.network_name()
781
server_url = 'bzr://example.com/'
782
self.permit_url(server_url)
783
client = FakeClient(server_url)
784
client.add_unknown_method_response('BzrDir.find_repositoryV3')
785
client.add_success_response('ok', '', 'no', 'no', 'no')
786
# A real repository instance will be created to determine the network
788
client.add_success_response_with_body(
789
"Bazaar-NG meta directory, format 1\n", 'ok')
790
client.add_success_response_with_body(
791
reference_format.get_format_string(), 'ok')
792
# PackRepository wants to do a stat
793
client.add_success_response('stat', '0', '65535')
794
remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
796
bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
798
repo = bzrdir.open_repository()
800
[('call', 'BzrDir.find_repositoryV3', ('quack/',)),
801
('call', 'BzrDir.find_repositoryV2', ('quack/',)),
802
('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
803
('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
804
('call', 'stat', ('/quack/.bzr/repository',)),
807
self.assertEqual(network_name, repo._format.network_name())
809
def test_current_server(self):
810
reference_format = self.get_repo_format()
811
network_name = reference_format.network_name()
812
transport = MemoryTransport()
813
transport.mkdir('quack')
814
transport = transport.clone('quack')
815
client = FakeClient(transport.base)
816
client.add_success_response('ok', '', 'no', 'no', 'no', network_name)
817
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
819
repo = bzrdir.open_repository()
821
[('call', 'BzrDir.find_repositoryV3', ('quack/',))],
823
self.assertEqual(network_name, repo._format.network_name())
826
class TestBzrDirFormatInitializeEx(TestRemote):
828
def test_success(self):
829
"""Simple test for typical successful call."""
830
fmt = bzrdir.RemoteBzrDirFormat()
831
default_format_name = BzrDirFormat.get_default_format().network_name()
832
transport = self.get_transport()
833
client = FakeClient(transport.base)
834
client.add_expected_call(
835
'BzrDirFormat.initialize_ex_1.16',
836
(default_format_name, 'path', 'False', 'False', 'False', '',
837
'', '', '', 'False'),
839
('.', 'no', 'no', 'yes', 'repo fmt', 'repo bzrdir fmt',
840
'bzrdir fmt', 'False', '', '', 'repo lock token'))
841
# XXX: It would be better to call fmt.initialize_on_transport_ex, but
842
# it's currently hard to test that without supplying a real remote
843
# transport connected to a real server.
844
result = fmt._initialize_on_transport_ex_rpc(client, 'path',
845
transport, False, False, False, None, None, None, None, False)
846
self.assertFinished(client)
848
def test_error(self):
849
"""Error responses are translated, e.g. 'PermissionDenied' raises the
850
corresponding error from the client.
852
fmt = bzrdir.RemoteBzrDirFormat()
853
default_format_name = BzrDirFormat.get_default_format().network_name()
854
transport = self.get_transport()
855
client = FakeClient(transport.base)
856
client.add_expected_call(
857
'BzrDirFormat.initialize_ex_1.16',
858
(default_format_name, 'path', 'False', 'False', 'False', '',
859
'', '', '', 'False'),
861
('PermissionDenied', 'path', 'extra info'))
862
# XXX: It would be better to call fmt.initialize_on_transport_ex, but
863
# it's currently hard to test that without supplying a real remote
864
# transport connected to a real server.
865
err = self.assertRaises(errors.PermissionDenied,
866
fmt._initialize_on_transport_ex_rpc, client, 'path', transport,
867
False, False, False, None, None, None, None, False)
868
self.assertEqual('path', err.path)
869
self.assertEqual(': extra info', err.extra)
870
self.assertFinished(client)
872
def test_error_from_real_server(self):
873
"""Integration test for error translation."""
874
transport = self.make_smart_server('foo')
875
transport = transport.clone('no-such-path')
876
fmt = bzrdir.RemoteBzrDirFormat()
877
err = self.assertRaises(errors.NoSuchFile,
878
fmt.initialize_on_transport_ex, transport, create_prefix=False)
881
203
class OldSmartClient(object):
882
204
"""A fake smart client for test_old_version that just returns a version one
883
205
response to the 'hello' (query version) command.
906
225
return OldSmartClient()
909
class RemoteBzrDirTestCase(TestRemote):
911
def make_remote_bzrdir(self, transport, client):
912
"""Make a RemotebzrDir using 'client' as the _client."""
913
return RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
917
class RemoteBranchTestCase(RemoteBzrDirTestCase):
919
def lock_remote_branch(self, branch):
920
"""Trick a RemoteBranch into thinking it is locked."""
921
branch._lock_mode = 'w'
922
branch._lock_count = 2
923
branch._lock_token = 'branch token'
924
branch._repo_lock_token = 'repo token'
925
branch.repository._lock_mode = 'w'
926
branch.repository._lock_count = 2
927
branch.repository._lock_token = 'repo token'
929
def make_remote_branch(self, transport, client):
930
"""Make a RemoteBranch using 'client' as its _SmartClient.
932
A RemoteBzrDir and RemoteRepository will also be created to fill out
933
the RemoteBranch, albeit with stub values for some of their attributes.
935
# we do not want bzrdir to make any remote calls, so use False as its
936
# _client. If it tries to make a remote call, this will fail
938
bzrdir = self.make_remote_bzrdir(transport, False)
939
repo = RemoteRepository(bzrdir, None, _client=client)
940
branch_format = self.get_branch_format()
941
format = RemoteBranchFormat(network_name=branch_format.network_name())
942
return RemoteBranch(bzrdir, repo, _client=client, format=format)
945
class TestBranchGetParent(RemoteBranchTestCase):
947
def test_no_parent(self):
948
# in an empty branch we decode the response properly
949
transport = MemoryTransport()
950
client = FakeClient(transport.base)
951
client.add_expected_call(
952
'Branch.get_stacked_on_url', ('quack/',),
953
'error', ('NotStacked',))
954
client.add_expected_call(
955
'Branch.get_parent', ('quack/',),
957
transport.mkdir('quack')
958
transport = transport.clone('quack')
959
branch = self.make_remote_branch(transport, client)
960
result = branch.get_parent()
961
self.assertFinished(client)
962
self.assertEqual(None, result)
964
def test_parent_relative(self):
965
transport = MemoryTransport()
966
client = FakeClient(transport.base)
967
client.add_expected_call(
968
'Branch.get_stacked_on_url', ('kwaak/',),
969
'error', ('NotStacked',))
970
client.add_expected_call(
971
'Branch.get_parent', ('kwaak/',),
972
'success', ('../foo/',))
973
transport.mkdir('kwaak')
974
transport = transport.clone('kwaak')
975
branch = self.make_remote_branch(transport, client)
976
result = branch.get_parent()
977
self.assertEqual(transport.clone('../foo').base, result)
979
def test_parent_absolute(self):
980
transport = MemoryTransport()
981
client = FakeClient(transport.base)
982
client.add_expected_call(
983
'Branch.get_stacked_on_url', ('kwaak/',),
984
'error', ('NotStacked',))
985
client.add_expected_call(
986
'Branch.get_parent', ('kwaak/',),
987
'success', ('http://foo/',))
988
transport.mkdir('kwaak')
989
transport = transport.clone('kwaak')
990
branch = self.make_remote_branch(transport, client)
991
result = branch.get_parent()
992
self.assertEqual('http://foo/', result)
993
self.assertFinished(client)
996
class TestBranchSetParentLocation(RemoteBranchTestCase):
998
def test_no_parent(self):
999
# We call the verb when setting parent to None
1000
transport = MemoryTransport()
1001
client = FakeClient(transport.base)
1002
client.add_expected_call(
1003
'Branch.get_stacked_on_url', ('quack/',),
1004
'error', ('NotStacked',))
1005
client.add_expected_call(
1006
'Branch.set_parent_location', ('quack/', 'b', 'r', ''),
1008
transport.mkdir('quack')
1009
transport = transport.clone('quack')
1010
branch = self.make_remote_branch(transport, client)
1011
branch._lock_token = 'b'
1012
branch._repo_lock_token = 'r'
1013
branch._set_parent_location(None)
1014
self.assertFinished(client)
1016
def test_parent(self):
1017
transport = MemoryTransport()
1018
client = FakeClient(transport.base)
1019
client.add_expected_call(
1020
'Branch.get_stacked_on_url', ('kwaak/',),
1021
'error', ('NotStacked',))
1022
client.add_expected_call(
1023
'Branch.set_parent_location', ('kwaak/', 'b', 'r', 'foo'),
1025
transport.mkdir('kwaak')
1026
transport = transport.clone('kwaak')
1027
branch = self.make_remote_branch(transport, client)
1028
branch._lock_token = 'b'
1029
branch._repo_lock_token = 'r'
1030
branch._set_parent_location('foo')
1031
self.assertFinished(client)
1033
def test_backwards_compat(self):
1034
self.setup_smart_server_with_call_log()
1035
branch = self.make_branch('.')
1036
self.reset_smart_call_log()
1037
verb = 'Branch.set_parent_location'
1038
self.disable_verb(verb)
1039
branch.set_parent('http://foo/')
1040
self.assertLength(12, self.hpss_calls)
1043
class TestBranchGetTagsBytes(RemoteBranchTestCase):
1045
def test_backwards_compat(self):
1046
self.setup_smart_server_with_call_log()
1047
branch = self.make_branch('.')
1048
self.reset_smart_call_log()
1049
verb = 'Branch.get_tags_bytes'
1050
self.disable_verb(verb)
1051
branch.tags.get_tag_dict()
1052
call_count = len([call for call in self.hpss_calls if
1053
call.call.method == verb])
1054
self.assertEqual(1, call_count)
1056
def test_trivial(self):
1057
transport = MemoryTransport()
1058
client = FakeClient(transport.base)
1059
client.add_expected_call(
1060
'Branch.get_stacked_on_url', ('quack/',),
1061
'error', ('NotStacked',))
1062
client.add_expected_call(
1063
'Branch.get_tags_bytes', ('quack/',),
1065
transport.mkdir('quack')
1066
transport = transport.clone('quack')
1067
branch = self.make_remote_branch(transport, client)
1068
result = branch.tags.get_tag_dict()
1069
self.assertFinished(client)
1070
self.assertEqual({}, result)
1073
class TestBranchSetTagsBytes(RemoteBranchTestCase):
1075
def test_trivial(self):
1076
transport = MemoryTransport()
1077
client = FakeClient(transport.base)
1078
client.add_expected_call(
1079
'Branch.get_stacked_on_url', ('quack/',),
1080
'error', ('NotStacked',))
1081
client.add_expected_call(
1082
'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1084
transport.mkdir('quack')
1085
transport = transport.clone('quack')
1086
branch = self.make_remote_branch(transport, client)
1087
self.lock_remote_branch(branch)
1088
branch._set_tags_bytes('tags bytes')
1089
self.assertFinished(client)
1090
self.assertEqual('tags bytes', client._calls[-1][-1])
1092
def test_backwards_compatible(self):
1093
transport = MemoryTransport()
1094
client = FakeClient(transport.base)
1095
client.add_expected_call(
1096
'Branch.get_stacked_on_url', ('quack/',),
1097
'error', ('NotStacked',))
1098
client.add_expected_call(
1099
'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1100
'unknown', ('Branch.set_tags_bytes',))
1101
transport.mkdir('quack')
1102
transport = transport.clone('quack')
1103
branch = self.make_remote_branch(transport, client)
1104
self.lock_remote_branch(branch)
1105
class StubRealBranch(object):
1108
def _set_tags_bytes(self, bytes):
1109
self.calls.append(('set_tags_bytes', bytes))
1110
real_branch = StubRealBranch()
1111
branch._real_branch = real_branch
1112
branch._set_tags_bytes('tags bytes')
1113
# Call a second time, to exercise the 'remote version already inferred'
1115
branch._set_tags_bytes('tags bytes')
1116
self.assertFinished(client)
1118
[('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1121
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
228
class TestBranchLastRevisionInfo(tests.TestCase):
1123
230
def test_empty_branch(self):
1124
231
# in an empty branch we decode the response properly
232
client = FakeClient([(('ok', '0', 'null:'), )])
1125
233
transport = MemoryTransport()
1126
client = FakeClient(transport.base)
1127
client.add_expected_call(
1128
'Branch.get_stacked_on_url', ('quack/',),
1129
'error', ('NotStacked',))
1130
client.add_expected_call(
1131
'Branch.last_revision_info', ('quack/',),
1132
'success', ('ok', '0', 'null:'))
1133
234
transport.mkdir('quack')
1134
235
transport = transport.clone('quack')
1135
branch = self.make_remote_branch(transport, client)
236
# we do not want bzrdir to make any remote calls
237
bzrdir = RemoteBzrDir(transport, _client=False)
238
branch = RemoteBranch(bzrdir, None, _client=client)
1136
239
result = branch.last_revision_info()
1137
self.assertFinished(client)
242
[('call', 'Branch.last_revision_info', ('///quack/',))],
1138
244
self.assertEqual((0, NULL_REVISION), result)
1140
246
def test_non_empty_branch(self):
1141
247
# in a non-empty branch we also decode the response properly
1142
248
revid = u'\xc8'.encode('utf8')
249
client = FakeClient([(('ok', '2', revid), )])
1143
250
transport = MemoryTransport()
1144
client = FakeClient(transport.base)
1145
client.add_expected_call(
1146
'Branch.get_stacked_on_url', ('kwaak/',),
1147
'error', ('NotStacked',))
1148
client.add_expected_call(
1149
'Branch.last_revision_info', ('kwaak/',),
1150
'success', ('ok', '2', revid))
1151
251
transport.mkdir('kwaak')
1152
252
transport = transport.clone('kwaak')
1153
branch = self.make_remote_branch(transport, client)
253
# we do not want bzrdir to make any remote calls
254
bzrdir = RemoteBzrDir(transport, _client=False)
255
branch = RemoteBranch(bzrdir, None, _client=client)
1154
256
result = branch.last_revision_info()
259
[('call', 'Branch.last_revision_info', ('///kwaak/',))],
1155
261
self.assertEqual((2, revid), result)
1158
class TestBranch_get_stacked_on_url(TestRemote):
1159
"""Test Branch._get_stacked_on_url rpc"""
1161
def test_get_stacked_on_invalid_url(self):
1162
# test that asking for a stacked on url the server can't access works.
1163
# This isn't perfect, but then as we're in the same process there
1164
# really isn't anything we can do to be 100% sure that the server
1165
# doesn't just open in - this test probably needs to be rewritten using
1166
# a spawn()ed server.
1167
stacked_branch = self.make_branch('stacked', format='1.9')
1168
memory_branch = self.make_branch('base', format='1.9')
1169
vfs_url = self.get_vfs_only_url('base')
1170
stacked_branch.set_stacked_on_url(vfs_url)
1171
transport = stacked_branch.bzrdir.root_transport
1172
client = FakeClient(transport.base)
1173
client.add_expected_call(
1174
'Branch.get_stacked_on_url', ('stacked/',),
1175
'success', ('ok', vfs_url))
1176
# XXX: Multiple calls are bad, this second call documents what is
1178
client.add_expected_call(
1179
'Branch.get_stacked_on_url', ('stacked/',),
1180
'success', ('ok', vfs_url))
1181
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
1183
repo_fmt = remote.RemoteRepositoryFormat()
1184
repo_fmt._custom_format = stacked_branch.repository._format
1185
branch = RemoteBranch(bzrdir, RemoteRepository(bzrdir, repo_fmt),
1187
result = branch.get_stacked_on_url()
1188
self.assertEqual(vfs_url, result)
1190
def test_backwards_compatible(self):
1191
# like with bzr1.6 with no Branch.get_stacked_on_url rpc
1192
base_branch = self.make_branch('base', format='1.6')
1193
stacked_branch = self.make_branch('stacked', format='1.6')
1194
stacked_branch.set_stacked_on_url('../base')
1195
client = FakeClient(self.get_url())
1196
branch_network_name = self.get_branch_format().network_name()
1197
client.add_expected_call(
1198
'BzrDir.open_branchV3', ('stacked/',),
1199
'success', ('branch', branch_network_name))
1200
client.add_expected_call(
1201
'BzrDir.find_repositoryV3', ('stacked/',),
1202
'success', ('ok', '', 'no', 'no', 'yes',
1203
stacked_branch.repository._format.network_name()))
1204
# called twice, once from constructor and then again by us
1205
client.add_expected_call(
1206
'Branch.get_stacked_on_url', ('stacked/',),
1207
'unknown', ('Branch.get_stacked_on_url',))
1208
client.add_expected_call(
1209
'Branch.get_stacked_on_url', ('stacked/',),
1210
'unknown', ('Branch.get_stacked_on_url',))
1211
# this will also do vfs access, but that goes direct to the transport
1212
# and isn't seen by the FakeClient.
1213
bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1214
remote.RemoteBzrDirFormat(), _client=client)
1215
branch = bzrdir.open_branch()
1216
result = branch.get_stacked_on_url()
1217
self.assertEqual('../base', result)
1218
self.assertFinished(client)
1219
# it's in the fallback list both for the RemoteRepository and its vfs
1221
self.assertEqual(1, len(branch.repository._fallback_repositories))
1223
len(branch.repository._real_repository._fallback_repositories))
1225
def test_get_stacked_on_real_branch(self):
1226
base_branch = self.make_branch('base', format='1.6')
1227
stacked_branch = self.make_branch('stacked', format='1.6')
1228
stacked_branch.set_stacked_on_url('../base')
1229
reference_format = self.get_repo_format()
1230
network_name = reference_format.network_name()
1231
client = FakeClient(self.get_url())
1232
branch_network_name = self.get_branch_format().network_name()
1233
client.add_expected_call(
1234
'BzrDir.open_branchV3', ('stacked/',),
1235
'success', ('branch', branch_network_name))
1236
client.add_expected_call(
1237
'BzrDir.find_repositoryV3', ('stacked/',),
1238
'success', ('ok', '', 'no', 'no', 'yes', network_name))
1239
# called twice, once from constructor and then again by us
1240
client.add_expected_call(
1241
'Branch.get_stacked_on_url', ('stacked/',),
1242
'success', ('ok', '../base'))
1243
client.add_expected_call(
1244
'Branch.get_stacked_on_url', ('stacked/',),
1245
'success', ('ok', '../base'))
1246
bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1247
remote.RemoteBzrDirFormat(), _client=client)
1248
branch = bzrdir.open_branch()
1249
result = branch.get_stacked_on_url()
1250
self.assertEqual('../base', result)
1251
self.assertFinished(client)
1252
# it's in the fallback list both for the RemoteRepository.
1253
self.assertEqual(1, len(branch.repository._fallback_repositories))
1254
# And we haven't had to construct a real repository.
1255
self.assertEqual(None, branch.repository._real_repository)
1258
class TestBranchSetLastRevision(RemoteBranchTestCase):
264
class TestBranchSetLastRevision(tests.TestCase):
1260
266
def test_set_empty(self):
1261
267
# set_revision_history([]) is translated to calling
1262
268
# Branch.set_last_revision(path, '') on the wire.
269
client = FakeClient([
271
(('ok', 'branch token', 'repo token'), ),
1263
276
transport = MemoryTransport()
1264
277
transport.mkdir('branch')
1265
278
transport = transport.clone('branch')
1267
client = FakeClient(transport.base)
1268
client.add_expected_call(
1269
'Branch.get_stacked_on_url', ('branch/',),
1270
'error', ('NotStacked',))
1271
client.add_expected_call(
1272
'Branch.lock_write', ('branch/', '', ''),
1273
'success', ('ok', 'branch token', 'repo token'))
1274
client.add_expected_call(
1275
'Branch.last_revision_info',
1277
'success', ('ok', '0', 'null:'))
1278
client.add_expected_call(
1279
'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'null:',),
1281
client.add_expected_call(
1282
'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1284
branch = self.make_remote_branch(transport, client)
280
bzrdir = RemoteBzrDir(transport, _client=False)
281
branch = RemoteBranch(bzrdir, None, _client=client)
1285
282
# This is a hack to work around the problem that RemoteBranch currently
1286
283
# unnecessarily invokes _ensure_real upon a call to lock_write.
1287
284
branch._ensure_real = lambda: None
1288
285
branch.lock_write()
1289
287
result = branch.set_revision_history([])
289
[('call', 'Branch.set_last_revision',
290
('///branch/', 'branch token', 'repo token', 'null:'))],
1291
293
self.assertEqual(None, result)
1292
self.assertFinished(client)
1294
295
def test_set_nonempty(self):
1295
296
# set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
1296
297
# Branch.set_last_revision(path, rev-idN) on the wire.
298
client = FakeClient([
300
(('ok', 'branch token', 'repo token'), ),
1297
305
transport = MemoryTransport()
1298
306
transport.mkdir('branch')
1299
307
transport = transport.clone('branch')
1301
client = FakeClient(transport.base)
1302
client.add_expected_call(
1303
'Branch.get_stacked_on_url', ('branch/',),
1304
'error', ('NotStacked',))
1305
client.add_expected_call(
1306
'Branch.lock_write', ('branch/', '', ''),
1307
'success', ('ok', 'branch token', 'repo token'))
1308
client.add_expected_call(
1309
'Branch.last_revision_info',
1311
'success', ('ok', '0', 'null:'))
1313
encoded_body = bz2.compress('\n'.join(lines))
1314
client.add_success_response_with_body(encoded_body, 'ok')
1315
client.add_expected_call(
1316
'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'rev-id2',),
1318
client.add_expected_call(
1319
'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1321
branch = self.make_remote_branch(transport, client)
309
bzrdir = RemoteBzrDir(transport, _client=False)
310
branch = RemoteBranch(bzrdir, None, _client=client)
1322
311
# This is a hack to work around the problem that RemoteBranch currently
1323
312
# unnecessarily invokes _ensure_real upon a call to lock_write.
1324
313
branch._ensure_real = lambda: None
1325
314
# Lock the branch, reset the record of remote calls.
1326
315
branch.lock_write()
1327
318
result = branch.set_revision_history(['rev-id1', 'rev-id2'])
320
[('call', 'Branch.set_last_revision',
321
('///branch/', 'branch token', 'repo token', 'rev-id2'))],
1329
324
self.assertEqual(None, result)
1330
self.assertFinished(client)
1332
326
def test_no_such_revision(self):
327
# A response of 'NoSuchRevision' is translated into an exception.
328
client = FakeClient([
330
(('ok', 'branch token', 'repo token'), ),
332
(('NoSuchRevision', 'rev-id'), ),
1333
335
transport = MemoryTransport()
1334
336
transport.mkdir('branch')
1335
337
transport = transport.clone('branch')
1336
# A response of 'NoSuchRevision' is translated into an exception.
1337
client = FakeClient(transport.base)
1338
client.add_expected_call(
1339
'Branch.get_stacked_on_url', ('branch/',),
1340
'error', ('NotStacked',))
1341
client.add_expected_call(
1342
'Branch.lock_write', ('branch/', '', ''),
1343
'success', ('ok', 'branch token', 'repo token'))
1344
client.add_expected_call(
1345
'Branch.last_revision_info',
1347
'success', ('ok', '0', 'null:'))
1348
# get_graph calls to construct the revision history, for the set_rh
1351
encoded_body = bz2.compress('\n'.join(lines))
1352
client.add_success_response_with_body(encoded_body, 'ok')
1353
client.add_expected_call(
1354
'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'rev-id',),
1355
'error', ('NoSuchRevision', 'rev-id'))
1356
client.add_expected_call(
1357
'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1360
branch = self.make_remote_branch(transport, client)
339
bzrdir = RemoteBzrDir(transport, _client=False)
340
branch = RemoteBranch(bzrdir, None, _client=client)
341
branch._ensure_real = lambda: None
1361
342
branch.lock_write()
1362
345
self.assertRaises(
1363
346
errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
1365
self.assertFinished(client)
1367
def test_tip_change_rejected(self):
1368
"""TipChangeRejected responses cause a TipChangeRejected exception to
1371
transport = MemoryTransport()
1372
transport.mkdir('branch')
1373
transport = transport.clone('branch')
1374
client = FakeClient(transport.base)
1375
rejection_msg_unicode = u'rejection message\N{INTERROBANG}'
1376
rejection_msg_utf8 = rejection_msg_unicode.encode('utf8')
1377
client.add_expected_call(
1378
'Branch.get_stacked_on_url', ('branch/',),
1379
'error', ('NotStacked',))
1380
client.add_expected_call(
1381
'Branch.lock_write', ('branch/', '', ''),
1382
'success', ('ok', 'branch token', 'repo token'))
1383
client.add_expected_call(
1384
'Branch.last_revision_info',
1386
'success', ('ok', '0', 'null:'))
1388
encoded_body = bz2.compress('\n'.join(lines))
1389
client.add_success_response_with_body(encoded_body, 'ok')
1390
client.add_expected_call(
1391
'Branch.set_last_revision', ('branch/', 'branch token', 'repo token', 'rev-id',),
1392
'error', ('TipChangeRejected', rejection_msg_utf8))
1393
client.add_expected_call(
1394
'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1396
branch = self.make_remote_branch(transport, client)
1397
branch._ensure_real = lambda: None
1399
# The 'TipChangeRejected' error response triggered by calling
1400
# set_revision_history causes a TipChangeRejected exception.
1401
err = self.assertRaises(
1402
errors.TipChangeRejected, branch.set_revision_history, ['rev-id'])
1403
# The UTF-8 message from the response has been decoded into a unicode
1405
self.assertIsInstance(err.msg, unicode)
1406
self.assertEqual(rejection_msg_unicode, err.msg)
1408
self.assertFinished(client)
1411
class TestBranchSetLastRevisionInfo(RemoteBranchTestCase):
1413
def test_set_last_revision_info(self):
1414
# set_last_revision_info(num, 'rev-id') is translated to calling
1415
# Branch.set_last_revision_info(num, 'rev-id') on the wire.
1416
transport = MemoryTransport()
1417
transport.mkdir('branch')
1418
transport = transport.clone('branch')
1419
client = FakeClient(transport.base)
1420
# get_stacked_on_url
1421
client.add_error_response('NotStacked')
1423
client.add_success_response('ok', 'branch token', 'repo token')
1424
# query the current revision
1425
client.add_success_response('ok', '0', 'null:')
1427
client.add_success_response('ok')
1429
client.add_success_response('ok')
1431
branch = self.make_remote_branch(transport, client)
1432
# Lock the branch, reset the record of remote calls.
1435
result = branch.set_last_revision_info(1234, 'a-revision-id')
1437
[('call', 'Branch.last_revision_info', ('branch/',)),
1438
('call', 'Branch.set_last_revision_info',
1439
('branch/', 'branch token', 'repo token',
1440
'1234', 'a-revision-id'))],
1442
self.assertEqual(None, result)
1444
def test_no_such_revision(self):
1445
# A response of 'NoSuchRevision' is translated into an exception.
1446
transport = MemoryTransport()
1447
transport.mkdir('branch')
1448
transport = transport.clone('branch')
1449
client = FakeClient(transport.base)
1450
# get_stacked_on_url
1451
client.add_error_response('NotStacked')
1453
client.add_success_response('ok', 'branch token', 'repo token')
1455
client.add_error_response('NoSuchRevision', 'revid')
1457
client.add_success_response('ok')
1459
branch = self.make_remote_branch(transport, client)
1460
# Lock the branch, reset the record of remote calls.
1465
errors.NoSuchRevision, branch.set_last_revision_info, 123, 'revid')
1468
def test_backwards_compatibility(self):
1469
"""If the server does not support the Branch.set_last_revision_info
1470
verb (which is new in 1.4), then the client falls back to VFS methods.
1472
# This test is a little messy. Unlike most tests in this file, it
1473
# doesn't purely test what a Remote* object sends over the wire, and
1474
# how it reacts to responses from the wire. It instead relies partly
1475
# on asserting that the RemoteBranch will call
1476
# self._real_branch.set_last_revision_info(...).
1478
# First, set up our RemoteBranch with a FakeClient that raises
1479
# UnknownSmartMethod, and a StubRealBranch that logs how it is called.
1480
transport = MemoryTransport()
1481
transport.mkdir('branch')
1482
transport = transport.clone('branch')
1483
client = FakeClient(transport.base)
1484
client.add_expected_call(
1485
'Branch.get_stacked_on_url', ('branch/',),
1486
'error', ('NotStacked',))
1487
client.add_expected_call(
1488
'Branch.last_revision_info',
1490
'success', ('ok', '0', 'null:'))
1491
client.add_expected_call(
1492
'Branch.set_last_revision_info',
1493
('branch/', 'branch token', 'repo token', '1234', 'a-revision-id',),
1494
'unknown', 'Branch.set_last_revision_info')
1496
branch = self.make_remote_branch(transport, client)
1497
class StubRealBranch(object):
1500
def set_last_revision_info(self, revno, revision_id):
1502
('set_last_revision_info', revno, revision_id))
1503
def _clear_cached_state(self):
1505
real_branch = StubRealBranch()
1506
branch._real_branch = real_branch
1507
self.lock_remote_branch(branch)
1509
# Call set_last_revision_info, and verify it behaved as expected.
1510
result = branch.set_last_revision_info(1234, 'a-revision-id')
1512
[('set_last_revision_info', 1234, 'a-revision-id')],
1514
self.assertFinished(client)
1516
def test_unexpected_error(self):
1517
# If the server sends an error the client doesn't understand, it gets
1518
# turned into an UnknownErrorFromSmartServer, which is presented as a
1519
# non-internal error to the user.
1520
transport = MemoryTransport()
1521
transport.mkdir('branch')
1522
transport = transport.clone('branch')
1523
client = FakeClient(transport.base)
1524
# get_stacked_on_url
1525
client.add_error_response('NotStacked')
1527
client.add_success_response('ok', 'branch token', 'repo token')
1529
client.add_error_response('UnexpectedError')
1531
client.add_success_response('ok')
1533
branch = self.make_remote_branch(transport, client)
1534
# Lock the branch, reset the record of remote calls.
1538
err = self.assertRaises(
1539
errors.UnknownErrorFromSmartServer,
1540
branch.set_last_revision_info, 123, 'revid')
1541
self.assertEqual(('UnexpectedError',), err.error_tuple)
1544
def test_tip_change_rejected(self):
1545
"""TipChangeRejected responses cause a TipChangeRejected exception to
1548
transport = MemoryTransport()
1549
transport.mkdir('branch')
1550
transport = transport.clone('branch')
1551
client = FakeClient(transport.base)
1552
# get_stacked_on_url
1553
client.add_error_response('NotStacked')
1555
client.add_success_response('ok', 'branch token', 'repo token')
1557
client.add_error_response('TipChangeRejected', 'rejection message')
1559
client.add_success_response('ok')
1561
branch = self.make_remote_branch(transport, client)
1562
# Lock the branch, reset the record of remote calls.
1564
self.addCleanup(branch.unlock)
1567
# The 'TipChangeRejected' error response triggered by calling
1568
# set_last_revision_info causes a TipChangeRejected exception.
1569
err = self.assertRaises(
1570
errors.TipChangeRejected,
1571
branch.set_last_revision_info, 123, 'revid')
1572
self.assertEqual('rejection message', err.msg)
1575
class TestBranchGetSetConfig(RemoteBranchTestCase):
350
class TestBranchControlGetBranchConf(tests.TestCaseWithMemoryTransport):
351
"""Test branch.control_files api munging...
353
We special case RemoteBranch.control_files.get('branch.conf') to
354
call a specific API so that RemoteBranch's can intercept configuration
355
file reading, allowing them to signal to the client about things like
356
'email is configured for commits'.
1577
359
def test_get_branch_conf(self):
1578
360
# in an empty branch we decode the response properly
1579
client = FakeClient()
1580
client.add_expected_call(
1581
'Branch.get_stacked_on_url', ('memory:///',),
1582
'error', ('NotStacked',),)
1583
client.add_success_response_with_body('# config file body', 'ok')
1584
transport = MemoryTransport()
1585
branch = self.make_remote_branch(transport, client)
1586
config = branch.get_config()
1587
config.has_explicit_nickname()
361
client = FakeClient([(('ok', ), 'config file body')])
362
# we need to make a real branch because the remote_branch.control_files
363
# will trigger _ensure_real.
364
branch = self.make_branch('quack')
365
transport = branch.bzrdir.root_transport
366
# we do not want bzrdir to make any remote calls
367
bzrdir = RemoteBzrDir(transport, _client=False)
368
branch = RemoteBranch(bzrdir, None, _client=client)
369
result = branch.control_files.get('branch.conf')
1588
370
self.assertEqual(
1589
[('call', 'Branch.get_stacked_on_url', ('memory:///',)),
1590
('call_expecting_body', 'Branch.get_config_file', ('memory:///',))],
371
[('call_expecting_body', 'Branch.get_config_file', ('///quack/',))],
1593
def test_get_multi_line_branch_conf(self):
1594
# Make sure that multiple-line branch.conf files are supported
1596
# https://bugs.edge.launchpad.net/bzr/+bug/354075
1597
client = FakeClient()
1598
client.add_expected_call(
1599
'Branch.get_stacked_on_url', ('memory:///',),
1600
'error', ('NotStacked',),)
1601
client.add_success_response_with_body('a = 1\nb = 2\nc = 3\n', 'ok')
1602
transport = MemoryTransport()
1603
branch = self.make_remote_branch(transport, client)
1604
config = branch.get_config()
1605
self.assertEqual(u'2', config.get_user_option('b'))
1607
def test_set_option(self):
1608
client = FakeClient()
1609
client.add_expected_call(
1610
'Branch.get_stacked_on_url', ('memory:///',),
1611
'error', ('NotStacked',),)
1612
client.add_expected_call(
1613
'Branch.lock_write', ('memory:///', '', ''),
1614
'success', ('ok', 'branch token', 'repo token'))
1615
client.add_expected_call(
1616
'Branch.set_config_option', ('memory:///', 'branch token',
1617
'repo token', 'foo', 'bar', ''),
1619
client.add_expected_call(
1620
'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
1622
transport = MemoryTransport()
1623
branch = self.make_remote_branch(transport, client)
1625
config = branch._get_config()
1626
config.set_option('foo', 'bar')
1628
self.assertFinished(client)
1630
def test_backwards_compat_set_option(self):
1631
self.setup_smart_server_with_call_log()
1632
branch = self.make_branch('.')
1633
verb = 'Branch.set_config_option'
1634
self.disable_verb(verb)
1636
self.addCleanup(branch.unlock)
1637
self.reset_smart_call_log()
1638
branch._get_config().set_option('value', 'name')
1639
self.assertLength(10, self.hpss_calls)
1640
self.assertEqual('value', branch._get_config().get_option('name'))
1643
class TestBranchLockWrite(RemoteBranchTestCase):
373
self.assertEqual('config file body', result.read())
376
class TestBranchLockWrite(tests.TestCase):
1645
378
def test_lock_write_unlockable(self):
379
client = FakeClient([(('UnlockableTransport', ), '')])
1646
380
transport = MemoryTransport()
1647
client = FakeClient(transport.base)
1648
client.add_expected_call(
1649
'Branch.get_stacked_on_url', ('quack/',),
1650
'error', ('NotStacked',),)
1651
client.add_expected_call(
1652
'Branch.lock_write', ('quack/', '', ''),
1653
'error', ('UnlockableTransport',))
1654
381
transport.mkdir('quack')
1655
382
transport = transport.clone('quack')
1656
branch = self.make_remote_branch(transport, client)
383
# we do not want bzrdir to make any remote calls
384
bzrdir = RemoteBzrDir(transport, _client=False)
385
branch = RemoteBranch(bzrdir, None, _client=client)
1657
386
self.assertRaises(errors.UnlockableTransport, branch.lock_write)
1658
self.assertFinished(client)
1661
class TestBzrDirGetSetConfig(RemoteBzrDirTestCase):
1663
def test__get_config(self):
1664
client = FakeClient()
1665
client.add_success_response_with_body('default_stack_on = /\n', 'ok')
1666
transport = MemoryTransport()
1667
bzrdir = self.make_remote_bzrdir(transport, client)
1668
config = bzrdir.get_config()
1669
self.assertEqual('/', config.get_default_stack_on())
1670
387
self.assertEqual(
1671
[('call_expecting_body', 'BzrDir.get_config_file', ('memory:///',))],
388
[('call', 'Branch.lock_write', ('///quack/', '', ''))],
1674
def test_set_option_uses_vfs(self):
1675
self.setup_smart_server_with_call_log()
1676
bzrdir = self.make_bzrdir('.')
1677
self.reset_smart_call_log()
1678
config = bzrdir.get_config()
1679
config.set_default_stack_on('/')
1680
self.assertLength(3, self.hpss_calls)
1682
def test_backwards_compat_get_option(self):
1683
self.setup_smart_server_with_call_log()
1684
bzrdir = self.make_bzrdir('.')
1685
verb = 'BzrDir.get_config_file'
1686
self.disable_verb(verb)
1687
self.reset_smart_call_log()
1688
self.assertEqual(None,
1689
bzrdir._get_config().get_option('default_stack_on'))
1690
self.assertLength(3, self.hpss_calls)
1693
392
class TestTransportIsReadonly(tests.TestCase):
1695
394
def test_true(self):
1696
client = FakeClient()
1697
client.add_success_response('yes')
395
client = FakeClient([(('yes',), '')])
1698
396
transport = RemoteTransport('bzr://example.com/', medium=False,
1700
398
self.assertEqual(True, transport.is_readonly())
1881
class TestRepositoryGetGraph(TestRemoteRepository):
1883
def test_get_graph(self):
1884
# get_graph returns a graph with a custom parents provider.
1885
transport_path = 'quack'
1886
repo, client = self.setup_fake_client_and_repository(transport_path)
1887
graph = repo.get_graph()
1888
self.assertNotEqual(graph._parents_provider, repo)
1891
class TestRepositoryGetParentMap(TestRemoteRepository):
1893
def test_get_parent_map_caching(self):
1894
# get_parent_map returns from cache until unlock()
1895
# setup a reponse with two revisions
1896
r1 = u'\u0e33'.encode('utf8')
1897
r2 = u'\u0dab'.encode('utf8')
1898
lines = [' '.join([r2, r1]), r1]
1899
encoded_body = bz2.compress('\n'.join(lines))
1901
transport_path = 'quack'
1902
repo, client = self.setup_fake_client_and_repository(transport_path)
1903
client.add_success_response_with_body(encoded_body, 'ok')
1904
client.add_success_response_with_body(encoded_body, 'ok')
1906
graph = repo.get_graph()
1907
parents = graph.get_parent_map([r2])
1908
self.assertEqual({r2: (r1,)}, parents)
1909
# locking and unlocking deeper should not reset
1912
parents = graph.get_parent_map([r1])
1913
self.assertEqual({r1: (NULL_REVISION,)}, parents)
1915
[('call_with_body_bytes_expecting_body',
1916
'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
1920
# now we call again, and it should use the second response.
1922
graph = repo.get_graph()
1923
parents = graph.get_parent_map([r1])
1924
self.assertEqual({r1: (NULL_REVISION,)}, parents)
1926
[('call_with_body_bytes_expecting_body',
1927
'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
1929
('call_with_body_bytes_expecting_body',
1930
'Repository.get_parent_map', ('quack/', 'include-missing:', r1),
1936
def test_get_parent_map_reconnects_if_unknown_method(self):
1937
transport_path = 'quack'
1938
rev_id = 'revision-id'
1939
repo, client = self.setup_fake_client_and_repository(transport_path)
1940
client.add_unknown_method_response('Repository.get_parent_map')
1941
client.add_success_response_with_body(rev_id, 'ok')
1942
self.assertFalse(client._medium._is_remote_before((1, 2)))
1943
parents = repo.get_parent_map([rev_id])
1945
[('call_with_body_bytes_expecting_body',
1946
'Repository.get_parent_map', ('quack/', 'include-missing:',
1948
('disconnect medium',),
1949
('call_expecting_body', 'Repository.get_revision_graph',
1952
# The medium is now marked as being connected to an older server
1953
self.assertTrue(client._medium._is_remote_before((1, 2)))
1954
self.assertEqual({rev_id: ('null:',)}, parents)
1956
def test_get_parent_map_fallback_parentless_node(self):
1957
"""get_parent_map falls back to get_revision_graph on old servers. The
1958
results from get_revision_graph are tweaked to match the get_parent_map
1961
Specifically, a {key: ()} result from get_revision_graph means "no
1962
parents" for that key, which in get_parent_map results should be
1963
represented as {key: ('null:',)}.
1965
This is the test for https://bugs.launchpad.net/bzr/+bug/214894
1967
rev_id = 'revision-id'
1968
transport_path = 'quack'
1969
repo, client = self.setup_fake_client_and_repository(transport_path)
1970
client.add_success_response_with_body(rev_id, 'ok')
1971
client._medium._remember_remote_is_before((1, 2))
1972
parents = repo.get_parent_map([rev_id])
1974
[('call_expecting_body', 'Repository.get_revision_graph',
1977
self.assertEqual({rev_id: ('null:',)}, parents)
1979
def test_get_parent_map_unexpected_response(self):
1980
repo, client = self.setup_fake_client_and_repository('path')
1981
client.add_success_response('something unexpected!')
1983
errors.UnexpectedSmartServerResponse,
1984
repo.get_parent_map, ['a-revision-id'])
1986
def test_get_parent_map_negative_caches_missing_keys(self):
1987
self.setup_smart_server_with_call_log()
1988
repo = self.make_repository('foo')
1989
self.assertIsInstance(repo, RemoteRepository)
1991
self.addCleanup(repo.unlock)
1992
self.reset_smart_call_log()
1993
graph = repo.get_graph()
1994
self.assertEqual({},
1995
graph.get_parent_map(['some-missing', 'other-missing']))
1996
self.assertLength(1, self.hpss_calls)
1997
# No call if we repeat this
1998
self.reset_smart_call_log()
1999
graph = repo.get_graph()
2000
self.assertEqual({},
2001
graph.get_parent_map(['some-missing', 'other-missing']))
2002
self.assertLength(0, self.hpss_calls)
2003
# Asking for more unknown keys makes a request.
2004
self.reset_smart_call_log()
2005
graph = repo.get_graph()
2006
self.assertEqual({},
2007
graph.get_parent_map(['some-missing', 'other-missing',
2009
self.assertLength(1, self.hpss_calls)
2011
def disableExtraResults(self):
2012
self.overrideAttr(SmartServerRepositoryGetParentMap,
2013
'no_extra_results', True)
2015
def test_null_cached_missing_and_stop_key(self):
2016
self.setup_smart_server_with_call_log()
2017
# Make a branch with a single revision.
2018
builder = self.make_branch_builder('foo')
2019
builder.start_series()
2020
builder.build_snapshot('first', None, [
2021
('add', ('', 'root-id', 'directory', ''))])
2022
builder.finish_series()
2023
branch = builder.get_branch()
2024
repo = branch.repository
2025
self.assertIsInstance(repo, RemoteRepository)
2026
# Stop the server from sending extra results.
2027
self.disableExtraResults()
2029
self.addCleanup(repo.unlock)
2030
self.reset_smart_call_log()
2031
graph = repo.get_graph()
2032
# Query for 'first' and 'null:'. Because 'null:' is a parent of
2033
# 'first' it will be a candidate for the stop_keys of subsequent
2034
# requests, and because 'null:' was queried but not returned it will be
2035
# cached as missing.
2036
self.assertEqual({'first': ('null:',)},
2037
graph.get_parent_map(['first', 'null:']))
2038
# Now query for another key. This request will pass along a recipe of
2039
# start and stop keys describing the already cached results, and this
2040
# recipe's revision count must be correct (or else it will trigger an
2041
# error from the server).
2042
self.assertEqual({}, graph.get_parent_map(['another-key']))
2043
# This assertion guards against disableExtraResults silently failing to
2044
# work, thus invalidating the test.
2045
self.assertLength(2, self.hpss_calls)
2047
def test_get_parent_map_gets_ghosts_from_result(self):
2048
# asking for a revision should negatively cache close ghosts in its
2050
self.setup_smart_server_with_call_log()
2051
tree = self.make_branch_and_memory_tree('foo')
2054
builder = treebuilder.TreeBuilder()
2055
builder.start_tree(tree)
2057
builder.finish_tree()
2058
tree.set_parent_ids(['non-existant'], allow_leftmost_as_ghost=True)
2059
rev_id = tree.commit('')
2063
self.addCleanup(tree.unlock)
2064
repo = tree.branch.repository
2065
self.assertIsInstance(repo, RemoteRepository)
2067
repo.get_parent_map([rev_id])
2068
self.reset_smart_call_log()
2069
# Now asking for rev_id's ghost parent should not make calls
2070
self.assertEqual({}, repo.get_parent_map(['non-existant']))
2071
self.assertLength(0, self.hpss_calls)
2074
class TestGetParentMapAllowsNew(tests.TestCaseWithTransport):
2076
def test_allows_new_revisions(self):
2077
"""get_parent_map's results can be updated by commit."""
2078
smart_server = test_server.SmartTCPServer_for_testing()
2079
self.start_server(smart_server)
2080
self.make_branch('branch')
2081
branch = Branch.open(smart_server.get_url() + '/branch')
2082
tree = branch.create_checkout('tree', lightweight=True)
2084
self.addCleanup(tree.unlock)
2085
graph = tree.branch.repository.get_graph()
2086
# This provides an opportunity for the missing rev-id to be cached.
2087
self.assertEqual({}, graph.get_parent_map(['rev1']))
2088
tree.commit('message', rev_id='rev1')
2089
graph = tree.branch.repository.get_graph()
2090
self.assertEqual({'rev1': ('null:',)}, graph.get_parent_map(['rev1']))
2093
531
class TestRepositoryGetRevisionGraph(TestRemoteRepository):
2095
533
def test_null_revision(self):
2096
534
# a null revision has the predictable result {}, we should have no wire
2097
535
# traffic when calling it with this argument
536
responses = [(('notused', ), '')]
2098
537
transport_path = 'empty'
2099
repo, client = self.setup_fake_client_and_repository(transport_path)
2100
client.add_success_response('notused')
2101
# actual RemoteRepository.get_revision_graph is gone, but there's an
2102
# equivalent private method for testing
2103
result = repo._get_revision_graph(NULL_REVISION)
538
repo, client = self.setup_fake_client_and_repository(
539
responses, transport_path)
540
result = repo.get_revision_graph(NULL_REVISION)
2104
541
self.assertEqual([], client._calls)
2105
542
self.assertEqual({}, result)
2132
568
lines = [' '.join([r2, r11, r12]), r11, r12]
2133
569
encoded_body = '\n'.join(lines)
571
responses = [(('ok', ), encoded_body)]
2135
572
transport_path = 'sinhala'
2136
repo, client = self.setup_fake_client_and_repository(transport_path)
2137
client.add_success_response_with_body(encoded_body, 'ok')
2138
result = repo._get_revision_graph(r2)
573
repo, client = self.setup_fake_client_and_repository(
574
responses, transport_path)
575
result = repo.get_revision_graph(r2)
2139
576
self.assertEqual(
2140
577
[('call_expecting_body', 'Repository.get_revision_graph',
578
('///sinhala/', r2))],
2143
self.assertEqual({r11: (), r12: (), r2: (r11, r12), }, result)
580
self.assertEqual({r11: [], r12: [], r2: [r11, r12], }, result)
2145
582
def test_no_such_revision(self):
584
responses = [(('nosuchrevision', revid), '')]
2147
585
transport_path = 'sinhala'
2148
repo, client = self.setup_fake_client_and_repository(transport_path)
2149
client.add_error_response('nosuchrevision', revid)
586
repo, client = self.setup_fake_client_and_repository(
587
responses, transport_path)
2150
588
# also check that the right revision is reported in the error
2151
589
self.assertRaises(errors.NoSuchRevision,
2152
repo._get_revision_graph, revid)
590
repo.get_revision_graph, revid)
2153
591
self.assertEqual(
2154
592
[('call_expecting_body', 'Repository.get_revision_graph',
2155
('sinhala/', revid))],
593
('///sinhala/', revid))],
2158
def test_unexpected_error(self):
2160
transport_path = 'sinhala'
2161
repo, client = self.setup_fake_client_and_repository(transport_path)
2162
client.add_error_response('AnUnexpectedError')
2163
e = self.assertRaises(errors.UnknownErrorFromSmartServer,
2164
repo._get_revision_graph, revid)
2165
self.assertEqual(('AnUnexpectedError',), e.error_tuple)
2168
class TestRepositoryGetRevIdForRevno(TestRemoteRepository):
2171
repo, client = self.setup_fake_client_and_repository('quack')
2172
client.add_expected_call(
2173
'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2174
'success', ('ok', 'rev-five'))
2175
result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
2176
self.assertEqual((True, 'rev-five'), result)
2177
self.assertFinished(client)
2179
def test_history_incomplete(self):
2180
repo, client = self.setup_fake_client_and_repository('quack')
2181
client.add_expected_call(
2182
'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2183
'success', ('history-incomplete', 10, 'rev-ten'))
2184
result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
2185
self.assertEqual((False, (10, 'rev-ten')), result)
2186
self.assertFinished(client)
2188
def test_history_incomplete_with_fallback(self):
2189
"""A 'history-incomplete' response causes the fallback repository to be
2190
queried too, if one is set.
2192
# Make a repo with a fallback repo, both using a FakeClient.
2193
format = remote.response_tuple_to_repo_format(
2194
('yes', 'no', 'yes', 'fake-network-name'))
2195
repo, client = self.setup_fake_client_and_repository('quack')
2196
repo._format = format
2197
fallback_repo, ignored = self.setup_fake_client_and_repository(
2199
fallback_repo._client = client
2200
repo.add_fallback_repository(fallback_repo)
2201
# First the client should ask the primary repo
2202
client.add_expected_call(
2203
'Repository.get_rev_id_for_revno', ('quack/', 1, (42, 'rev-foo')),
2204
'success', ('history-incomplete', 2, 'rev-two'))
2205
# Then it should ask the fallback, using revno/revid from the
2206
# history-incomplete response as the known revno/revid.
2207
client.add_expected_call(
2208
'Repository.get_rev_id_for_revno',('fallback/', 1, (2, 'rev-two')),
2209
'success', ('ok', 'rev-one'))
2210
result = repo.get_rev_id_for_revno(1, (42, 'rev-foo'))
2211
self.assertEqual((True, 'rev-one'), result)
2212
self.assertFinished(client)
2214
def test_nosuchrevision(self):
2215
# 'nosuchrevision' is returned when the known-revid is not found in the
2216
# remote repo. The client translates that response to NoSuchRevision.
2217
repo, client = self.setup_fake_client_and_repository('quack')
2218
client.add_expected_call(
2219
'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2220
'error', ('nosuchrevision', 'rev-foo'))
2222
errors.NoSuchRevision,
2223
repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
2224
self.assertFinished(client)
2226
def test_branch_fallback_locking(self):
2227
"""RemoteBranch.get_rev_id takes a read lock, and tries to call the
2228
get_rev_id_for_revno verb. If the verb is unknown the VFS fallback
2229
will be invoked, which will fail if the repo is unlocked.
2231
self.setup_smart_server_with_call_log()
2232
tree = self.make_branch_and_memory_tree('.')
2234
rev1 = tree.commit('First')
2235
rev2 = tree.commit('Second')
2237
branch = tree.branch
2238
self.assertFalse(branch.is_locked())
2239
self.reset_smart_call_log()
2240
verb = 'Repository.get_rev_id_for_revno'
2241
self.disable_verb(verb)
2242
self.assertEqual(rev1, branch.get_rev_id(1))
2243
self.assertLength(1, [call for call in self.hpss_calls if
2244
call.call.method == verb])
2247
597
class TestRepositoryIsShared(TestRemoteRepository):
2249
599
def test_is_shared(self):
2250
600
# ('yes', ) for Repository.is_shared -> 'True'.
601
responses = [(('yes', ), )]
2251
602
transport_path = 'quack'
2252
repo, client = self.setup_fake_client_and_repository(transport_path)
2253
client.add_success_response('yes')
603
repo, client = self.setup_fake_client_and_repository(
604
responses, transport_path)
2254
605
result = repo.is_shared()
2255
606
self.assertEqual(
2256
[('call', 'Repository.is_shared', ('quack/',))],
607
[('call', 'Repository.is_shared', ('///quack/',))],
2258
609
self.assertEqual(True, result)
2260
611
def test_is_not_shared(self):
2261
612
# ('no', ) for Repository.is_shared -> 'False'.
613
responses = [(('no', ), )]
2262
614
transport_path = 'qwack'
2263
repo, client = self.setup_fake_client_and_repository(transport_path)
2264
client.add_success_response('no')
615
repo, client = self.setup_fake_client_and_repository(
616
responses, transport_path)
2265
617
result = repo.is_shared()
2266
618
self.assertEqual(
2267
[('call', 'Repository.is_shared', ('qwack/',))],
619
[('call', 'Repository.is_shared', ('///qwack/',))],
2269
621
self.assertEqual(False, result)
2355
686
def test_none(self):
2356
687
# repo.has_revision(None) should not cause any traffic.
2357
688
transport_path = 'quack'
2358
repo, client = self.setup_fake_client_and_repository(transport_path)
690
repo, client = self.setup_fake_client_and_repository(
691
responses, transport_path)
2360
693
# The null revision is always there, so has_revision(None) == True.
2361
self.assertEqual(True, repo.has_revision(NULL_REVISION))
694
self.assertEqual(True, repo.has_revision(None))
2363
696
# The remote repo shouldn't be accessed.
2364
697
self.assertEqual([], client._calls)
2367
class TestRepositoryInsertStreamBase(TestRemoteRepository):
2368
"""Base class for Repository.insert_stream and .insert_stream_1.19
2372
def checkInsertEmptyStream(self, repo, client):
2373
"""Insert an empty stream, checking the result.
2375
This checks that there are no resume_tokens or missing_keys, and that
2376
the client is finished.
2378
sink = repo._get_sink()
2379
fmt = repository.RepositoryFormat.get_default_format()
2380
resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2381
self.assertEqual([], resume_tokens)
2382
self.assertEqual(set(), missing_keys)
2383
self.assertFinished(client)
2386
class TestRepositoryInsertStream(TestRepositoryInsertStreamBase):
2387
"""Tests for using Repository.insert_stream verb when the _1.19 variant is
2390
This test case is very similar to TestRepositoryInsertStream_1_19.
2394
TestRemoteRepository.setUp(self)
2395
self.disable_verb('Repository.insert_stream_1.19')
2397
def test_unlocked_repo(self):
2398
transport_path = 'quack'
2399
repo, client = self.setup_fake_client_and_repository(transport_path)
2400
client.add_expected_call(
2401
'Repository.insert_stream_1.19', ('quack/', ''),
2402
'unknown', ('Repository.insert_stream_1.19',))
2403
client.add_expected_call(
2404
'Repository.insert_stream', ('quack/', ''),
2406
client.add_expected_call(
2407
'Repository.insert_stream', ('quack/', ''),
2409
self.checkInsertEmptyStream(repo, client)
2411
def test_locked_repo_with_no_lock_token(self):
2412
transport_path = 'quack'
2413
repo, client = self.setup_fake_client_and_repository(transport_path)
2414
client.add_expected_call(
2415
'Repository.lock_write', ('quack/', ''),
2416
'success', ('ok', ''))
2417
client.add_expected_call(
2418
'Repository.insert_stream_1.19', ('quack/', ''),
2419
'unknown', ('Repository.insert_stream_1.19',))
2420
client.add_expected_call(
2421
'Repository.insert_stream', ('quack/', ''),
2423
client.add_expected_call(
2424
'Repository.insert_stream', ('quack/', ''),
2427
self.checkInsertEmptyStream(repo, client)
2429
def test_locked_repo_with_lock_token(self):
2430
transport_path = 'quack'
2431
repo, client = self.setup_fake_client_and_repository(transport_path)
2432
client.add_expected_call(
2433
'Repository.lock_write', ('quack/', ''),
2434
'success', ('ok', 'a token'))
2435
client.add_expected_call(
2436
'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2437
'unknown', ('Repository.insert_stream_1.19',))
2438
client.add_expected_call(
2439
'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2441
client.add_expected_call(
2442
'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2445
self.checkInsertEmptyStream(repo, client)
2447
def test_stream_with_inventory_deltas(self):
2448
"""'inventory-deltas' substreams cannot be sent to the
2449
Repository.insert_stream verb, because not all servers that implement
2450
that verb will accept them. So when one is encountered the RemoteSink
2451
immediately stops using that verb and falls back to VFS insert_stream.
2453
transport_path = 'quack'
2454
repo, client = self.setup_fake_client_and_repository(transport_path)
2455
client.add_expected_call(
2456
'Repository.insert_stream_1.19', ('quack/', ''),
2457
'unknown', ('Repository.insert_stream_1.19',))
2458
client.add_expected_call(
2459
'Repository.insert_stream', ('quack/', ''),
2461
client.add_expected_call(
2462
'Repository.insert_stream', ('quack/', ''),
2464
# Create a fake real repository for insert_stream to fall back on, so
2465
# that we can directly see the records the RemoteSink passes to the
2470
def insert_stream(self, stream, src_format, resume_tokens):
2471
for substream_kind, substream in stream:
2472
self.records.append(
2473
(substream_kind, [record.key for record in substream]))
2474
return ['fake tokens'], ['fake missing keys']
2475
fake_real_sink = FakeRealSink()
2476
class FakeRealRepository:
2477
def _get_sink(self):
2478
return fake_real_sink
2479
def is_in_write_group(self):
2481
def refresh_data(self):
2483
repo._real_repository = FakeRealRepository()
2484
sink = repo._get_sink()
2485
fmt = repository.RepositoryFormat.get_default_format()
2486
stream = self.make_stream_with_inv_deltas(fmt)
2487
resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2488
# Every record from the first inventory delta should have been sent to
2490
expected_records = [
2491
('inventory-deltas', [('rev2',), ('rev3',)]),
2492
('texts', [('some-rev', 'some-file')])]
2493
self.assertEqual(expected_records, fake_real_sink.records)
2494
# The return values from the real sink's insert_stream are propagated
2495
# back to the original caller.
2496
self.assertEqual(['fake tokens'], resume_tokens)
2497
self.assertEqual(['fake missing keys'], missing_keys)
2498
self.assertFinished(client)
2500
def make_stream_with_inv_deltas(self, fmt):
2501
"""Make a simple stream with an inventory delta followed by more
2502
records and more substreams to test that all records and substreams
2503
from that point on are used.
2505
This sends, in order:
2506
* inventories substream: rev1, rev2, rev3. rev2 and rev3 are
2508
* texts substream: (some-rev, some-file)
2510
# Define a stream using generators so that it isn't rewindable.
2511
inv = inventory.Inventory(revision_id='rev1')
2512
inv.root.revision = 'rev1'
2513
def stream_with_inv_delta():
2514
yield ('inventories', inventories_substream())
2515
yield ('inventory-deltas', inventory_delta_substream())
2517
versionedfile.FulltextContentFactory(
2518
('some-rev', 'some-file'), (), None, 'content')])
2519
def inventories_substream():
2520
# An empty inventory fulltext. This will be streamed normally.
2521
text = fmt._serializer.write_inventory_to_string(inv)
2522
yield versionedfile.FulltextContentFactory(
2523
('rev1',), (), None, text)
2524
def inventory_delta_substream():
2525
# An inventory delta. This can't be streamed via this verb, so it
2526
# will trigger a fallback to VFS insert_stream.
2527
entry = inv.make_entry(
2528
'directory', 'newdir', inv.root.file_id, 'newdir-id')
2529
entry.revision = 'ghost'
2530
delta = [(None, 'newdir', 'newdir-id', entry)]
2531
serializer = inventory_delta.InventoryDeltaSerializer(
2532
versioned_root=True, tree_references=False)
2533
lines = serializer.delta_to_lines('rev1', 'rev2', delta)
2534
yield versionedfile.ChunkedContentFactory(
2535
('rev2',), (('rev1',)), None, lines)
2537
lines = serializer.delta_to_lines('rev1', 'rev3', delta)
2538
yield versionedfile.ChunkedContentFactory(
2539
('rev3',), (('rev1',)), None, lines)
2540
return stream_with_inv_delta()
2543
class TestRepositoryInsertStream_1_19(TestRepositoryInsertStreamBase):
2545
def test_unlocked_repo(self):
2546
transport_path = 'quack'
2547
repo, client = self.setup_fake_client_and_repository(transport_path)
2548
client.add_expected_call(
2549
'Repository.insert_stream_1.19', ('quack/', ''),
2551
client.add_expected_call(
2552
'Repository.insert_stream_1.19', ('quack/', ''),
2554
self.checkInsertEmptyStream(repo, client)
2556
def test_locked_repo_with_no_lock_token(self):
2557
transport_path = 'quack'
2558
repo, client = self.setup_fake_client_and_repository(transport_path)
2559
client.add_expected_call(
2560
'Repository.lock_write', ('quack/', ''),
2561
'success', ('ok', ''))
2562
client.add_expected_call(
2563
'Repository.insert_stream_1.19', ('quack/', ''),
2565
client.add_expected_call(
2566
'Repository.insert_stream_1.19', ('quack/', ''),
2569
self.checkInsertEmptyStream(repo, client)
2571
def test_locked_repo_with_lock_token(self):
2572
transport_path = 'quack'
2573
repo, client = self.setup_fake_client_and_repository(transport_path)
2574
client.add_expected_call(
2575
'Repository.lock_write', ('quack/', ''),
2576
'success', ('ok', 'a token'))
2577
client.add_expected_call(
2578
'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2580
client.add_expected_call(
2581
'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2584
self.checkInsertEmptyStream(repo, client)
2587
700
class TestRepositoryTarball(TestRemoteRepository):
2589
702
# This is a canned tarball reponse we can validate against
2636
769
self.assertFalse(isinstance(dest_repo, RemoteRepository))
2637
770
self.assertTrue(isinstance(src_repo, RemoteRepository))
2638
771
src_repo.copy_content_into(dest_repo)
2641
class _StubRealPackRepository(object):
2643
def __init__(self, calls):
2645
self._pack_collection = _StubPackCollection(calls)
2647
def is_in_write_group(self):
2650
def refresh_data(self):
2651
self.calls.append(('pack collection reload_pack_names',))
2654
class _StubPackCollection(object):
2656
def __init__(self, calls):
2660
self.calls.append(('pack collection autopack',))
2663
class TestRemotePackRepositoryAutoPack(TestRemoteRepository):
2664
"""Tests for RemoteRepository.autopack implementation."""
2667
"""When the server returns 'ok' and there's no _real_repository, then
2668
nothing else happens: the autopack method is done.
2670
transport_path = 'quack'
2671
repo, client = self.setup_fake_client_and_repository(transport_path)
2672
client.add_expected_call(
2673
'PackRepository.autopack', ('quack/',), 'success', ('ok',))
2675
self.assertFinished(client)
2677
def test_ok_with_real_repo(self):
2678
"""When the server returns 'ok' and there is a _real_repository, then
2679
the _real_repository's reload_pack_name's method will be called.
2681
transport_path = 'quack'
2682
repo, client = self.setup_fake_client_and_repository(transport_path)
2683
client.add_expected_call(
2684
'PackRepository.autopack', ('quack/',),
2686
repo._real_repository = _StubRealPackRepository(client._calls)
2689
[('call', 'PackRepository.autopack', ('quack/',)),
2690
('pack collection reload_pack_names',)],
2693
def test_backwards_compatibility(self):
2694
"""If the server does not recognise the PackRepository.autopack verb,
2695
fallback to the real_repository's implementation.
2697
transport_path = 'quack'
2698
repo, client = self.setup_fake_client_and_repository(transport_path)
2699
client.add_unknown_method_response('PackRepository.autopack')
2700
def stub_ensure_real():
2701
client._calls.append(('_ensure_real',))
2702
repo._real_repository = _StubRealPackRepository(client._calls)
2703
repo._ensure_real = stub_ensure_real
2706
[('call', 'PackRepository.autopack', ('quack/',)),
2708
('pack collection autopack',)],
2712
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
2713
"""Base class for unit tests for bzrlib.remote._translate_error."""
2715
def translateTuple(self, error_tuple, **context):
2716
"""Call _translate_error with an ErrorFromSmartServer built from the
2719
:param error_tuple: A tuple of a smart server response, as would be
2720
passed to an ErrorFromSmartServer.
2721
:kwargs context: context items to call _translate_error with.
2723
:returns: The error raised by _translate_error.
2725
# Raise the ErrorFromSmartServer before passing it as an argument,
2726
# because _translate_error may need to re-raise it with a bare 'raise'
2728
server_error = errors.ErrorFromSmartServer(error_tuple)
2729
translated_error = self.translateErrorFromSmartServer(
2730
server_error, **context)
2731
return translated_error
2733
def translateErrorFromSmartServer(self, error_object, **context):
2734
"""Like translateTuple, but takes an already constructed
2735
ErrorFromSmartServer rather than a tuple.
2739
except errors.ErrorFromSmartServer, server_error:
2740
translated_error = self.assertRaises(
2741
errors.BzrError, remote._translate_error, server_error,
2743
return translated_error
2746
class TestErrorTranslationSuccess(TestErrorTranslationBase):
2747
"""Unit tests for bzrlib.remote._translate_error.
2749
Given an ErrorFromSmartServer (which has an error tuple from a smart
2750
server) and some context, _translate_error raises more specific errors from
2753
This test case covers the cases where _translate_error succeeds in
2754
translating an ErrorFromSmartServer to something better. See
2755
TestErrorTranslationRobustness for other cases.
2758
def test_NoSuchRevision(self):
2759
branch = self.make_branch('')
2761
translated_error = self.translateTuple(
2762
('NoSuchRevision', revid), branch=branch)
2763
expected_error = errors.NoSuchRevision(branch, revid)
2764
self.assertEqual(expected_error, translated_error)
2766
def test_nosuchrevision(self):
2767
repository = self.make_repository('')
2769
translated_error = self.translateTuple(
2770
('nosuchrevision', revid), repository=repository)
2771
expected_error = errors.NoSuchRevision(repository, revid)
2772
self.assertEqual(expected_error, translated_error)
2774
def test_nobranch(self):
2775
bzrdir = self.make_bzrdir('')
2776
translated_error = self.translateTuple(('nobranch',), bzrdir=bzrdir)
2777
expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
2778
self.assertEqual(expected_error, translated_error)
2780
def test_nobranch_one_arg(self):
2781
bzrdir = self.make_bzrdir('')
2782
translated_error = self.translateTuple(
2783
('nobranch', 'extra detail'), bzrdir=bzrdir)
2784
expected_error = errors.NotBranchError(
2785
path=bzrdir.root_transport.base,
2786
detail='extra detail')
2787
self.assertEqual(expected_error, translated_error)
2789
def test_LockContention(self):
2790
translated_error = self.translateTuple(('LockContention',))
2791
expected_error = errors.LockContention('(remote lock)')
2792
self.assertEqual(expected_error, translated_error)
2794
def test_UnlockableTransport(self):
2795
bzrdir = self.make_bzrdir('')
2796
translated_error = self.translateTuple(
2797
('UnlockableTransport',), bzrdir=bzrdir)
2798
expected_error = errors.UnlockableTransport(bzrdir.root_transport)
2799
self.assertEqual(expected_error, translated_error)
2801
def test_LockFailed(self):
2802
lock = 'str() of a server lock'
2803
why = 'str() of why'
2804
translated_error = self.translateTuple(('LockFailed', lock, why))
2805
expected_error = errors.LockFailed(lock, why)
2806
self.assertEqual(expected_error, translated_error)
2808
def test_TokenMismatch(self):
2809
token = 'a lock token'
2810
translated_error = self.translateTuple(('TokenMismatch',), token=token)
2811
expected_error = errors.TokenMismatch(token, '(remote token)')
2812
self.assertEqual(expected_error, translated_error)
2814
def test_Diverged(self):
2815
branch = self.make_branch('a')
2816
other_branch = self.make_branch('b')
2817
translated_error = self.translateTuple(
2818
('Diverged',), branch=branch, other_branch=other_branch)
2819
expected_error = errors.DivergedBranches(branch, other_branch)
2820
self.assertEqual(expected_error, translated_error)
2822
def test_ReadError_no_args(self):
2824
translated_error = self.translateTuple(('ReadError',), path=path)
2825
expected_error = errors.ReadError(path)
2826
self.assertEqual(expected_error, translated_error)
2828
def test_ReadError(self):
2830
translated_error = self.translateTuple(('ReadError', path))
2831
expected_error = errors.ReadError(path)
2832
self.assertEqual(expected_error, translated_error)
2834
def test_IncompatibleRepositories(self):
2835
translated_error = self.translateTuple(('IncompatibleRepositories',
2836
"repo1", "repo2", "details here"))
2837
expected_error = errors.IncompatibleRepositories("repo1", "repo2",
2839
self.assertEqual(expected_error, translated_error)
2841
def test_PermissionDenied_no_args(self):
2843
translated_error = self.translateTuple(('PermissionDenied',), path=path)
2844
expected_error = errors.PermissionDenied(path)
2845
self.assertEqual(expected_error, translated_error)
2847
def test_PermissionDenied_one_arg(self):
2849
translated_error = self.translateTuple(('PermissionDenied', path))
2850
expected_error = errors.PermissionDenied(path)
2851
self.assertEqual(expected_error, translated_error)
2853
def test_PermissionDenied_one_arg_and_context(self):
2854
"""Given a choice between a path from the local context and a path on
2855
the wire, _translate_error prefers the path from the local context.
2857
local_path = 'local path'
2858
remote_path = 'remote path'
2859
translated_error = self.translateTuple(
2860
('PermissionDenied', remote_path), path=local_path)
2861
expected_error = errors.PermissionDenied(local_path)
2862
self.assertEqual(expected_error, translated_error)
2864
def test_PermissionDenied_two_args(self):
2866
extra = 'a string with extra info'
2867
translated_error = self.translateTuple(
2868
('PermissionDenied', path, extra))
2869
expected_error = errors.PermissionDenied(path, extra)
2870
self.assertEqual(expected_error, translated_error)
2873
class TestErrorTranslationRobustness(TestErrorTranslationBase):
2874
"""Unit tests for bzrlib.remote._translate_error's robustness.
2876
TestErrorTranslationSuccess is for cases where _translate_error can
2877
translate successfully. This class about how _translate_err behaves when
2878
it fails to translate: it re-raises the original error.
2881
def test_unrecognised_server_error(self):
2882
"""If the error code from the server is not recognised, the original
2883
ErrorFromSmartServer is propagated unmodified.
2885
error_tuple = ('An unknown error tuple',)
2886
server_error = errors.ErrorFromSmartServer(error_tuple)
2887
translated_error = self.translateErrorFromSmartServer(server_error)
2888
expected_error = errors.UnknownErrorFromSmartServer(server_error)
2889
self.assertEqual(expected_error, translated_error)
2891
def test_context_missing_a_key(self):
2892
"""In case of a bug in the client, or perhaps an unexpected response
2893
from a server, _translate_error returns the original error tuple from
2894
the server and mutters a warning.
2896
# To translate a NoSuchRevision error _translate_error needs a 'branch'
2897
# in the context dict. So let's give it an empty context dict instead
2898
# to exercise its error recovery.
2900
error_tuple = ('NoSuchRevision', 'revid')
2901
server_error = errors.ErrorFromSmartServer(error_tuple)
2902
translated_error = self.translateErrorFromSmartServer(server_error)
2903
self.assertEqual(server_error, translated_error)
2904
# In addition to re-raising ErrorFromSmartServer, some debug info has
2905
# been muttered to the log file for developer to look at.
2906
self.assertContainsRe(
2908
"Missing key 'branch' in context")
2910
def test_path_missing(self):
2911
"""Some translations (PermissionDenied, ReadError) can determine the
2912
'path' variable from either the wire or the local context. If neither
2913
has it, then an error is raised.
2915
error_tuple = ('ReadError',)
2916
server_error = errors.ErrorFromSmartServer(error_tuple)
2917
translated_error = self.translateErrorFromSmartServer(server_error)
2918
self.assertEqual(server_error, translated_error)
2919
# In addition to re-raising ErrorFromSmartServer, some debug info has
2920
# been muttered to the log file for developer to look at.
2921
self.assertContainsRe(self.get_log(), "Missing key 'path' in context")
2924
class TestStacking(tests.TestCaseWithTransport):
2925
"""Tests for operations on stacked remote repositories.
2927
The underlying format type must support stacking.
2930
def test_access_stacked_remote(self):
2931
# based on <http://launchpad.net/bugs/261315>
2932
# make a branch stacked on another repository containing an empty
2933
# revision, then open it over hpss - we should be able to see that
2935
base_transport = self.get_transport()
2936
base_builder = self.make_branch_builder('base', format='1.9')
2937
base_builder.start_series()
2938
base_revid = base_builder.build_snapshot('rev-id', None,
2939
[('add', ('', None, 'directory', None))],
2941
base_builder.finish_series()
2942
stacked_branch = self.make_branch('stacked', format='1.9')
2943
stacked_branch.set_stacked_on_url('../base')
2944
# start a server looking at this
2945
smart_server = test_server.SmartTCPServer_for_testing()
2946
self.start_server(smart_server)
2947
remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
2948
# can get its branch and repository
2949
remote_branch = remote_bzrdir.open_branch()
2950
remote_repo = remote_branch.repository
2951
remote_repo.lock_read()
2953
# it should have an appropriate fallback repository, which should also
2954
# be a RemoteRepository
2955
self.assertLength(1, remote_repo._fallback_repositories)
2956
self.assertIsInstance(remote_repo._fallback_repositories[0],
2958
# and it has the revision committed to the underlying repository;
2959
# these have varying implementations so we try several of them
2960
self.assertTrue(remote_repo.has_revisions([base_revid]))
2961
self.assertTrue(remote_repo.has_revision(base_revid))
2962
self.assertEqual(remote_repo.get_revision(base_revid).message,
2965
remote_repo.unlock()
2967
def prepare_stacked_remote_branch(self):
2968
"""Get stacked_upon and stacked branches with content in each."""
2969
self.setup_smart_server_with_call_log()
2970
tree1 = self.make_branch_and_tree('tree1', format='1.9')
2971
tree1.commit('rev1', rev_id='rev1')
2972
tree2 = tree1.branch.bzrdir.sprout('tree2', stacked=True
2973
).open_workingtree()
2974
local_tree = tree2.branch.create_checkout('local')
2975
local_tree.commit('local changes make me feel good.')
2976
branch2 = Branch.open(self.get_url('tree2'))
2978
self.addCleanup(branch2.unlock)
2979
return tree1.branch, branch2
2981
def test_stacked_get_parent_map(self):
2982
# the public implementation of get_parent_map obeys stacking
2983
_, branch = self.prepare_stacked_remote_branch()
2984
repo = branch.repository
2985
self.assertEqual(['rev1'], repo.get_parent_map(['rev1']).keys())
2987
def test_unstacked_get_parent_map(self):
2988
# _unstacked_provider.get_parent_map ignores stacking
2989
_, branch = self.prepare_stacked_remote_branch()
2990
provider = branch.repository._unstacked_provider
2991
self.assertEqual([], provider.get_parent_map(['rev1']).keys())
2993
def fetch_stream_to_rev_order(self, stream):
2995
for kind, substream in stream:
2996
if not kind == 'revisions':
2999
for content in substream:
3000
result.append(content.key[-1])
3003
def get_ordered_revs(self, format, order, branch_factory=None):
3004
"""Get a list of the revisions in a stream to format format.
3006
:param format: The format of the target.
3007
:param order: the order that target should have requested.
3008
:param branch_factory: A callable to create a trunk and stacked branch
3009
to fetch from. If none, self.prepare_stacked_remote_branch is used.
3010
:result: The revision ids in the stream, in the order seen,
3011
the topological order of revisions in the source.
3013
unordered_format = bzrdir.format_registry.get(format)()
3014
target_repository_format = unordered_format.repository_format
3016
self.assertEqual(order, target_repository_format._fetch_order)
3017
if branch_factory is None:
3018
branch_factory = self.prepare_stacked_remote_branch
3019
_, stacked = branch_factory()
3020
source = stacked.repository._get_source(target_repository_format)
3021
tip = stacked.last_revision()
3022
revs = stacked.repository.get_ancestry(tip)
3023
search = graph.PendingAncestryResult([tip], stacked.repository)
3024
self.reset_smart_call_log()
3025
stream = source.get_stream(search)
3028
# We trust that if a revision is in the stream the rest of the new
3029
# content for it is too, as per our main fetch tests; here we are
3030
# checking that the revisions are actually included at all, and their
3032
return self.fetch_stream_to_rev_order(stream), revs
3034
def test_stacked_get_stream_unordered(self):
3035
# Repository._get_source.get_stream() from a stacked repository with
3036
# unordered yields the full data from both stacked and stacked upon
3038
rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered')
3039
self.assertEqual(set(expected_revs), set(rev_ord))
3040
# Getting unordered results should have made a streaming data request
3041
# from the server, then one from the backing branch.
3042
self.assertLength(2, self.hpss_calls)
3044
def test_stacked_on_stacked_get_stream_unordered(self):
3045
# Repository._get_source.get_stream() from a stacked repository which
3046
# is itself stacked yields the full data from all three sources.
3047
def make_stacked_stacked():
3048
_, stacked = self.prepare_stacked_remote_branch()
3049
tree = stacked.bzrdir.sprout('tree3', stacked=True
3050
).open_workingtree()
3051
local_tree = tree.branch.create_checkout('local-tree3')
3052
local_tree.commit('more local changes are better')
3053
branch = Branch.open(self.get_url('tree3'))
3055
self.addCleanup(branch.unlock)
3057
rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
3058
branch_factory=make_stacked_stacked)
3059
self.assertEqual(set(expected_revs), set(rev_ord))
3060
# Getting unordered results should have made a streaming data request
3061
# from the server, and one from each backing repo
3062
self.assertLength(3, self.hpss_calls)
3064
def test_stacked_get_stream_topological(self):
3065
# Repository._get_source.get_stream() from a stacked repository with
3066
# topological sorting yields the full data from both stacked and
3067
# stacked upon sources in topological order.
3068
rev_ord, expected_revs = self.get_ordered_revs('knit', 'topological')
3069
self.assertEqual(expected_revs, rev_ord)
3070
# Getting topological sort requires VFS calls still - one of which is
3071
# pushing up from the bound branch.
3072
self.assertLength(13, self.hpss_calls)
3074
def test_stacked_get_stream_groupcompress(self):
3075
# Repository._get_source.get_stream() from a stacked repository with
3076
# groupcompress sorting yields the full data from both stacked and
3077
# stacked upon sources in groupcompress order.
3078
raise tests.TestSkipped('No groupcompress ordered format available')
3079
rev_ord, expected_revs = self.get_ordered_revs('dev5', 'groupcompress')
3080
self.assertEqual(expected_revs, reversed(rev_ord))
3081
# Getting unordered results should have made a streaming data request
3082
# from the backing branch, and one from the stacked on branch.
3083
self.assertLength(2, self.hpss_calls)
3085
def test_stacked_pull_more_than_stacking_has_bug_360791(self):
3086
# When pulling some fixed amount of content that is more than the
3087
# source has (because some is coming from a fallback branch, no error
3088
# should be received. This was reported as bug 360791.
3089
# Need three branches: a trunk, a stacked branch, and a preexisting
3090
# branch pulling content from stacked and trunk.
3091
self.setup_smart_server_with_call_log()
3092
trunk = self.make_branch_and_tree('trunk', format="1.9-rich-root")
3093
r1 = trunk.commit('start')
3094
stacked_branch = trunk.branch.create_clone_on_transport(
3095
self.get_transport('stacked'), stacked_on=trunk.branch.base)
3096
local = self.make_branch('local', format='1.9-rich-root')
3097
local.repository.fetch(stacked_branch.repository,
3098
stacked_branch.last_revision())
3101
class TestRemoteBranchEffort(tests.TestCaseWithTransport):
3104
super(TestRemoteBranchEffort, self).setUp()
3105
# Create a smart server that publishes whatever the backing VFS server
3107
self.smart_server = test_server.SmartTCPServer_for_testing()
3108
self.start_server(self.smart_server, self.get_server())
3109
# Log all HPSS calls into self.hpss_calls.
3110
_SmartClient.hooks.install_named_hook(
3111
'call', self.capture_hpss_call, None)
3112
self.hpss_calls = []
3114
def capture_hpss_call(self, params):
3115
self.hpss_calls.append(params.method)
3117
def test_copy_content_into_avoids_revision_history(self):
3118
local = self.make_branch('local')
3119
remote_backing_tree = self.make_branch_and_tree('remote')
3120
remote_backing_tree.commit("Commit.")
3121
remote_branch_url = self.smart_server.get_url() + 'remote'
3122
remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3123
local.repository.fetch(remote_branch.repository)
3124
self.hpss_calls = []
3125
remote_branch.copy_content_into(local)
3126
self.assertFalse('Branch.revision_history' in self.hpss_calls)
added
removed
bzrlib/tests/test_remote.py
