57
54
RemoteRepositoryFormat,
59
from bzrlib.repofmt import groupcompress_repo, knitpack_repo
56
from bzrlib.repofmt import groupcompress_repo, pack_repo
60
57
from bzrlib.revision import NULL_REVISION
61
from bzrlib.smart import medium, request
58
from bzrlib.smart import medium
62
59
from bzrlib.smart.client import _SmartClient
63
from bzrlib.smart.repository import (
64
SmartServerRepositoryGetParentMap,
65
SmartServerRepositoryGetStream_1_19,
60
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
67
61
from bzrlib.tests import (
63
split_suite_by_condition,
70
from bzrlib.tests.scenarios import load_tests_apply_scenarios
71
67
from bzrlib.transport.memory import MemoryTransport
72
68
from bzrlib.transport.remote import (
74
70
RemoteSSHTransport,
75
71
RemoteTCPTransport,
79
load_tests = load_tests_apply_scenarios
82
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
74
def load_tests(standard_tests, module, loader):
75
to_adapt, result = split_suite_by_condition(
76
standard_tests, condition_isinstance(BasicRemoteObjectTests))
77
smart_server_version_scenarios = [
86
{'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
79
{'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
88
{'transport_server': test_server.SmartTCPServer_for_testing})]
81
{'transport_server': test_server.SmartTCPServer_for_testing})]
82
return multiply_tests(to_adapt, smart_server_version_scenarios, result)
85
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
92
88
super(BasicRemoteObjectTests, self).setUp()
96
92
self.addCleanup(self.transport.disconnect)
98
94
def test_create_remote_bzrdir(self):
99
b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
95
b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
100
96
self.assertIsInstance(b, BzrDir)
102
98
def test_open_remote_branch(self):
103
99
# open a standalone branch in the working directory
104
b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
100
b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
105
101
branch = b.open_branch()
106
102
self.assertIsInstance(branch, Branch)
470
466
client.add_expected_call(
471
467
'BzrDir.cloning_metadir', ('quack/', 'False'),
472
468
'success', (control_name, '', ('branch', ''))),
473
a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
469
a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
475
471
result = a_bzrdir.cloning_metadir()
476
472
# We should have got a reference control dir with default branch and
496
492
client.add_expected_call(
497
493
'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
498
494
self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
499
RemoteBzrDirFormat(), _client=client, _force_probe=True)
495
remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
500
496
self.assertFinished(client)
502
498
def test_present_without_workingtree(self):
503
499
client, transport = self.make_fake_client_and_transport()
504
500
client.add_expected_call(
505
501
'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
506
bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
502
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
507
503
_client=client, _force_probe=True)
508
504
self.assertIsInstance(bd, RemoteBzrDir)
509
505
self.assertFalse(bd.has_workingtree())
514
510
client, transport = self.make_fake_client_and_transport()
515
511
client.add_expected_call(
516
512
'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
517
bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
513
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
518
514
_client=client, _force_probe=True)
519
515
self.assertIsInstance(bd, RemoteBzrDir)
520
516
self.assertTrue(bd.has_workingtree())
527
523
'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
528
524
client.add_expected_call(
529
525
'BzrDir.open', ('quack/',), 'success', ('yes',))
530
bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
526
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
531
527
_client=client, _force_probe=True)
532
528
self.assertIsInstance(bd, RemoteBzrDir)
533
529
self.assertFinished(client)
549
545
'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
550
546
client.add_expected_call(
551
547
'BzrDir.open', ('quack/',), 'success', ('yes',))
552
bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
548
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
553
549
_client=client, _force_probe=True)
554
550
self.assertIsInstance(bd, RemoteBzrDir)
555
551
self.assertFinished(client)
725
721
format = branch._format
726
722
self.assertEqual(network_name, format.network_name())
728
def test_already_open_repo_and_reused_medium(self):
729
"""Bug 726584: create_branch(..., repository=repo) should work
730
regardless of what the smart medium's base URL is.
732
self.transport_server = test_server.SmartTCPServer_for_testing
733
transport = self.get_transport('.')
734
repo = self.make_repository('quack')
735
# Client's medium rooted a transport root (not at the bzrdir)
736
client = FakeClient(transport.base)
737
transport = transport.clone('quack')
738
reference_bzrdir_format = bzrdir.format_registry.get('default')()
739
reference_format = reference_bzrdir_format.get_branch_format()
740
network_name = reference_format.network_name()
741
reference_repo_fmt = reference_bzrdir_format.repository_format
742
reference_repo_name = reference_repo_fmt.network_name()
743
client.add_expected_call(
744
'BzrDir.create_branch', ('extra/quack/', network_name),
745
'success', ('ok', network_name, '', 'no', 'no', 'yes',
746
reference_repo_name))
747
a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
749
branch = a_bzrdir.create_branch(repository=repo)
750
# We should have got a remote branch
751
self.assertIsInstance(branch, remote.RemoteBranch)
752
# its format should have the settings from the response
753
format = branch._format
754
self.assertEqual(network_name, format.network_name())
757
725
class TestBzrDirCreateRepository(TestRemote):
1172
1140
[('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1175
class TestBranchHeadsToFetch(RemoteBranchTestCase):
1177
def test_uses_last_revision_info_and_tags_by_default(self):
1178
transport = MemoryTransport()
1179
client = FakeClient(transport.base)
1180
client.add_expected_call(
1181
'Branch.get_stacked_on_url', ('quack/',),
1182
'error', ('NotStacked',))
1183
client.add_expected_call(
1184
'Branch.last_revision_info', ('quack/',),
1185
'success', ('ok', '1', 'rev-tip'))
1186
# XXX: this will break if the default format's serialization of tags
1187
# changes, or if the RPC for fetching tags changes from get_tags_bytes.
1188
client.add_expected_call(
1189
'Branch.get_tags_bytes', ('quack/',),
1190
'success', ('d5:tag-17:rev-foo5:tag-27:rev-bare',))
1191
transport.mkdir('quack')
1192
transport = transport.clone('quack')
1193
branch = self.make_remote_branch(transport, client)
1194
result = branch.heads_to_fetch()
1195
self.assertFinished(client)
1197
(set(['rev-tip']), set(['rev-foo', 'rev-bar'])), result)
1199
def test_uses_rpc_for_formats_with_non_default_heads_to_fetch(self):
1200
transport = MemoryTransport()
1201
client = FakeClient(transport.base)
1202
client.add_expected_call(
1203
'Branch.get_stacked_on_url', ('quack/',),
1204
'error', ('NotStacked',))
1205
client.add_expected_call(
1206
'Branch.heads_to_fetch', ('quack/',),
1207
'success', (['tip'], ['tagged-1', 'tagged-2']))
1208
transport.mkdir('quack')
1209
transport = transport.clone('quack')
1210
branch = self.make_remote_branch(transport, client)
1211
branch._format._use_default_local_heads_to_fetch = lambda: False
1212
result = branch.heads_to_fetch()
1213
self.assertFinished(client)
1214
self.assertEqual((set(['tip']), set(['tagged-1', 'tagged-2'])), result)
1216
def test_backwards_compatible(self):
1217
self.setup_smart_server_with_call_log()
1218
# Make a branch with a single revision.
1219
builder = self.make_branch_builder('foo')
1220
builder.start_series()
1221
builder.build_snapshot('tip', None, [
1222
('add', ('', 'root-id', 'directory', ''))])
1223
builder.finish_series()
1224
branch = builder.get_branch()
1225
# Add two tags to that branch
1226
branch.tags.set_tag('tag-1', 'rev-1')
1227
branch.tags.set_tag('tag-2', 'rev-2')
1228
self.addCleanup(branch.lock_read().unlock)
1229
# Disable the heads_to_fetch verb
1230
verb = 'Branch.heads_to_fetch'
1231
self.disable_verb(verb)
1232
self.reset_smart_call_log()
1233
result = branch.heads_to_fetch()
1234
self.assertEqual((set(['tip']), set(['rev-1', 'rev-2'])), result)
1236
['Branch.last_revision_info', 'Branch.get_tags_bytes'],
1237
[call.call.method for call in self.hpss_calls])
1240
1143
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1242
1145
def test_empty_branch(self):
1405
1308
# unnecessarily invokes _ensure_real upon a call to lock_write.
1406
1309
branch._ensure_real = lambda: None
1407
1310
branch.lock_write()
1408
result = branch._set_last_revision(NULL_REVISION)
1311
result = branch.set_revision_history([])
1409
1312
branch.unlock()
1410
1313
self.assertEqual(None, result)
1411
1314
self.assertFinished(client)
1413
1316
def test_set_nonempty(self):
1414
# set_last_revision_info(N, rev-idN) is translated to calling
1317
# set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
1415
1318
# Branch.set_last_revision(path, rev-idN) on the wire.
1416
1319
transport = MemoryTransport()
1417
1320
transport.mkdir('branch')
1963
1865
class TestRepositoryFormat(TestRemoteRepository):
1965
1867
def test_fast_delta(self):
1966
true_name = groupcompress_repo.RepositoryFormat2a().network_name()
1868
true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
1967
1869
true_format = RemoteRepositoryFormat()
1968
1870
true_format._network_name = true_name
1969
1871
self.assertEqual(True, true_format.fast_deltas)
1970
false_name = knitpack_repo.RepositoryFormatKnitPack1().network_name()
1872
false_name = pack_repo.RepositoryFormatKnitPack1().network_name()
1971
1873
false_format = RemoteRepositoryFormat()
1972
1874
false_format._network_name = false_name
1973
1875
self.assertEqual(False, false_format.fast_deltas)
1975
1877
def test_get_format_description(self):
1976
1878
remote_repo_format = RemoteRepositoryFormat()
1977
real_format = repository.format_registry.get_default()
1879
real_format = repository.RepositoryFormat.get_default_format()
1978
1880
remote_repo_format._network_name = real_format.network_name()
1979
1881
self.assertEqual(remoted_description(real_format),
1980
1882
remote_repo_format.get_format_description())
2870
2772
('pack collection autopack',)],
2873
def test_oom_error_reporting(self):
2874
"""An out-of-memory condition on the server is reported clearly"""
2875
transport_path = 'quack'
2876
repo, client = self.setup_fake_client_and_repository(transport_path)
2877
client.add_expected_call(
2878
'PackRepository.autopack', ('quack/',),
2879
'error', ('MemoryError',))
2880
err = self.assertRaises(errors.BzrError, repo.autopack)
2881
self.assertContainsRe(str(err), "^remote server out of mem")
2884
2776
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
2885
2777
"""Base class for unit tests for bzrlib.remote._translate_error."""
2998
2883
expected_error = errors.DivergedBranches(branch, other_branch)
2999
2884
self.assertEqual(expected_error, translated_error)
3001
def test_NotStacked(self):
3002
branch = self.make_branch('')
3003
translated_error = self.translateTuple(('NotStacked',), branch=branch)
3004
expected_error = errors.NotStacked(branch)
3005
self.assertEqual(expected_error, translated_error)
3007
2886
def test_ReadError_no_args(self):
3008
2887
path = 'a path'
3009
2888
translated_error = self.translateTuple(('ReadError',), path=path)
3055
2933
expected_error = errors.PermissionDenied(path, extra)
3056
2934
self.assertEqual(expected_error, translated_error)
3058
# GZ 2011-03-02: TODO test for PermissionDenied with non-ascii 'extra'
3060
def test_NoSuchFile_context_path(self):
3061
local_path = "local path"
3062
translated_error = self.translateTuple(('ReadError', "remote path"),
3064
expected_error = errors.ReadError(local_path)
3065
self.assertEqual(expected_error, translated_error)
3067
def test_NoSuchFile_without_context(self):
3068
remote_path = "remote path"
3069
translated_error = self.translateTuple(('ReadError', remote_path))
3070
expected_error = errors.ReadError(remote_path)
3071
self.assertEqual(expected_error, translated_error)
3073
def test_ReadOnlyError(self):
3074
translated_error = self.translateTuple(('ReadOnlyError',))
3075
expected_error = errors.TransportNotPossible("readonly transport")
3076
self.assertEqual(expected_error, translated_error)
3078
def test_MemoryError(self):
3079
translated_error = self.translateTuple(('MemoryError',))
3080
self.assertStartsWith(str(translated_error),
3081
"remote server out of memory")
3083
def test_generic_IndexError_no_classname(self):
3084
err = errors.ErrorFromSmartServer(('error', "list index out of range"))
3085
translated_error = self.translateErrorFromSmartServer(err)
3086
expected_error = errors.UnknownErrorFromSmartServer(err)
3087
self.assertEqual(expected_error, translated_error)
3089
# GZ 2011-03-02: TODO test generic non-ascii error string
3091
def test_generic_KeyError(self):
3092
err = errors.ErrorFromSmartServer(('error', 'KeyError', "1"))
3093
translated_error = self.translateErrorFromSmartServer(err)
3094
expected_error = errors.UnknownErrorFromSmartServer(err)
3095
self.assertEqual(expected_error, translated_error)
3098
2937
class TestErrorTranslationRobustness(TestErrorTranslationBase):
3099
2938
"""Unit tests for bzrlib.remote._translate_error's robustness.
3244
3083
_, stacked = branch_factory()
3245
3084
source = stacked.repository._get_source(target_repository_format)
3246
3085
tip = stacked.last_revision()
3247
stacked.repository._ensure_real()
3248
graph = stacked.repository.get_graph()
3249
revs = [r for (r,ps) in graph.iter_ancestry([tip])
3250
if r != NULL_REVISION]
3252
search = _mod_graph.PendingAncestryResult([tip], stacked.repository)
3086
revs = stacked.repository.get_ancestry(tip)
3087
search = graph.PendingAncestryResult([tip], stacked.repository)
3253
3088
self.reset_smart_call_log()
3254
3089
stream = source.get_stream(search)
3255
3092
# We trust that if a revision is in the stream the rest of the new
3256
3093
# content for it is too, as per our main fetch tests; here we are
3257
3094
# checking that the revisions are actually included at all, and their
3344
3181
def test_copy_content_into_avoids_revision_history(self):
3345
3182
local = self.make_branch('local')
3346
builder = self.make_branch_builder('remote')
3347
builder.build_commit(message="Commit.")
3183
remote_backing_tree = self.make_branch_and_tree('remote')
3184
remote_backing_tree.commit("Commit.")
3348
3185
remote_branch_url = self.smart_server.get_url() + 'remote'
3349
3186
remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3350
3187
local.repository.fetch(remote_branch.repository)
3351
3188
self.hpss_calls = []
3352
3189
remote_branch.copy_content_into(local)
3353
3190
self.assertFalse('Branch.revision_history' in self.hpss_calls)
3355
def test_fetch_everything_needs_just_one_call(self):
3356
local = self.make_branch('local')
3357
builder = self.make_branch_builder('remote')
3358
builder.build_commit(message="Commit.")
3359
remote_branch_url = self.smart_server.get_url() + 'remote'
3360
remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3361
self.hpss_calls = []
3362
local.repository.fetch(remote_branch.repository,
3363
fetch_spec=_mod_graph.EverythingResult(remote_branch.repository))
3364
self.assertEqual(['Repository.get_stream_1.19'], self.hpss_calls)
3366
def override_verb(self, verb_name, verb):
3367
request_handlers = request.request_handlers
3368
orig_verb = request_handlers.get(verb_name)
3369
request_handlers.register(verb_name, verb, override_existing=True)
3370
self.addCleanup(request_handlers.register, verb_name, orig_verb,
3371
override_existing=True)
3373
def test_fetch_everything_backwards_compat(self):
3374
"""Can fetch with EverythingResult even with pre 2.4 servers.
3376
Pre-2.4 do not support 'everything' searches with the
3377
Repository.get_stream_1.19 verb.
3380
class OldGetStreamVerb(SmartServerRepositoryGetStream_1_19):
3381
"""A version of the Repository.get_stream_1.19 verb patched to
3382
reject 'everything' searches the way 2.3 and earlier do.
3384
def recreate_search(self, repository, search_bytes, discard_excess=False):
3385
verb_log.append(search_bytes.split('\n', 1)[0])
3386
if search_bytes == 'everything':
3387
return (None, request.FailedSmartServerResponse(('BadSearch',)))
3388
return super(OldGetStreamVerb,
3389
self).recreate_search(repository, search_bytes,
3390
discard_excess=discard_excess)
3391
self.override_verb('Repository.get_stream_1.19', OldGetStreamVerb)
3392
local = self.make_branch('local')
3393
builder = self.make_branch_builder('remote')
3394
builder.build_commit(message="Commit.")
3395
remote_branch_url = self.smart_server.get_url() + 'remote'
3396
remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3397
self.hpss_calls = []
3398
local.repository.fetch(remote_branch.repository,
3399
fetch_spec=_mod_graph.EverythingResult(remote_branch.repository))
3400
# make sure the overridden verb was used
3401
self.assertLength(1, verb_log)
3402
# more than one HPSS call is needed, but because it's a VFS callback
3403
# its hard to predict exactly how many.
3404
self.assertTrue(len(self.hpss_calls) > 1)
added
removed
bzrlib/tests/test_remote.py
