57
53
RemoteRepositoryFormat,
59
from bzrlib.repofmt import groupcompress_repo, knitpack_repo
55
from bzrlib.repofmt import groupcompress_repo, pack_repo
60
56
from bzrlib.revision import NULL_REVISION
61
from bzrlib.smart import medium, request
57
from bzrlib.smart import medium
62
58
from bzrlib.smart.client import _SmartClient
63
from bzrlib.smart.repository import (
64
SmartServerRepositoryGetParentMap,
65
SmartServerRepositoryGetStream_1_19,
59
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
67
60
from bzrlib.tests import (
62
split_suite_by_condition,
70
from bzrlib.tests.scenarios import load_tests_apply_scenarios
66
from bzrlib.transport import get_transport
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()
93
89
self.transport = self.get_transport()
94
90
# make a branch that can be opened over the smart transport
95
91
self.local_wt = BzrDir.create_standalone_workingtree('.')
96
self.addCleanup(self.transport.disconnect)
94
self.transport.disconnect()
95
tests.TestCaseWithTransport.tearDown(self)
98
97
def test_create_remote_bzrdir(self):
99
b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
98
b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
100
99
self.assertIsInstance(b, BzrDir)
102
101
def test_open_remote_branch(self):
103
102
# open a standalone branch in the working directory
104
b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
103
b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
105
104
branch = b.open_branch()
106
105
self.assertIsInstance(branch, Branch)
496
495
client.add_expected_call(
497
496
'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
498
497
self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
499
RemoteBzrDirFormat(), _client=client, _force_probe=True)
498
remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
500
499
self.assertFinished(client)
502
501
def test_present_without_workingtree(self):
503
502
client, transport = self.make_fake_client_and_transport()
504
503
client.add_expected_call(
505
504
'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
506
bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
505
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
507
506
_client=client, _force_probe=True)
508
507
self.assertIsInstance(bd, RemoteBzrDir)
509
508
self.assertFalse(bd.has_workingtree())
725
724
format = branch._format
726
725
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
728
class TestBzrDirCreateRepository(TestRemote):
1172
1143
[('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
client.add_expected_call(
1187
'Branch.get_config_file', ('quack/',),
1188
'success', ('ok',), '')
1189
transport.mkdir('quack')
1190
transport = transport.clone('quack')
1191
branch = self.make_remote_branch(transport, client)
1192
result = branch.heads_to_fetch()
1193
self.assertFinished(client)
1194
self.assertEqual((set(['rev-tip']), set()), result)
1196
def test_uses_last_revision_info_and_tags_when_set(self):
1197
transport = MemoryTransport()
1198
client = FakeClient(transport.base)
1199
client.add_expected_call(
1200
'Branch.get_stacked_on_url', ('quack/',),
1201
'error', ('NotStacked',))
1202
client.add_expected_call(
1203
'Branch.last_revision_info', ('quack/',),
1204
'success', ('ok', '1', 'rev-tip'))
1205
client.add_expected_call(
1206
'Branch.get_config_file', ('quack/',),
1207
'success', ('ok',), 'branch.fetch_tags = True')
1208
# XXX: this will break if the default format's serialization of tags
1209
# changes, or if the RPC for fetching tags changes from get_tags_bytes.
1210
client.add_expected_call(
1211
'Branch.get_tags_bytes', ('quack/',),
1212
'success', ('d5:tag-17:rev-foo5:tag-27:rev-bare',))
1213
transport.mkdir('quack')
1214
transport = transport.clone('quack')
1215
branch = self.make_remote_branch(transport, client)
1216
result = branch.heads_to_fetch()
1217
self.assertFinished(client)
1219
(set(['rev-tip']), set(['rev-foo', 'rev-bar'])), result)
1221
def test_uses_rpc_for_formats_with_non_default_heads_to_fetch(self):
1222
transport = MemoryTransport()
1223
client = FakeClient(transport.base)
1224
client.add_expected_call(
1225
'Branch.get_stacked_on_url', ('quack/',),
1226
'error', ('NotStacked',))
1227
client.add_expected_call(
1228
'Branch.heads_to_fetch', ('quack/',),
1229
'success', (['tip'], ['tagged-1', 'tagged-2']))
1230
transport.mkdir('quack')
1231
transport = transport.clone('quack')
1232
branch = self.make_remote_branch(transport, client)
1233
branch._format._use_default_local_heads_to_fetch = lambda: False
1234
result = branch.heads_to_fetch()
1235
self.assertFinished(client)
1236
self.assertEqual((set(['tip']), set(['tagged-1', 'tagged-2'])), result)
1238
def make_branch_with_tags(self):
1239
self.setup_smart_server_with_call_log()
1240
# Make a branch with a single revision.
1241
builder = self.make_branch_builder('foo')
1242
builder.start_series()
1243
builder.build_snapshot('tip', None, [
1244
('add', ('', 'root-id', 'directory', ''))])
1245
builder.finish_series()
1246
branch = builder.get_branch()
1247
# Add two tags to that branch
1248
branch.tags.set_tag('tag-1', 'rev-1')
1249
branch.tags.set_tag('tag-2', 'rev-2')
1252
def test_backwards_compatible(self):
1253
branch = self.make_branch_with_tags()
1254
c = branch.get_config()
1255
c.set_user_option('branch.fetch_tags', 'True')
1256
self.addCleanup(branch.lock_read().unlock)
1257
# Disable the heads_to_fetch verb
1258
verb = 'Branch.heads_to_fetch'
1259
self.disable_verb(verb)
1260
self.reset_smart_call_log()
1261
result = branch.heads_to_fetch()
1262
self.assertEqual((set(['tip']), set(['rev-1', 'rev-2'])), result)
1264
['Branch.last_revision_info', 'Branch.get_config_file',
1265
'Branch.get_tags_bytes'],
1266
[call.call.method for call in self.hpss_calls])
1268
def test_backwards_compatible_no_tags(self):
1269
branch = self.make_branch_with_tags()
1270
c = branch.get_config()
1271
c.set_user_option('branch.fetch_tags', 'False')
1272
self.addCleanup(branch.lock_read().unlock)
1273
# Disable the heads_to_fetch verb
1274
verb = 'Branch.heads_to_fetch'
1275
self.disable_verb(verb)
1276
self.reset_smart_call_log()
1277
result = branch.heads_to_fetch()
1278
self.assertEqual((set(['tip']), set()), result)
1280
['Branch.last_revision_info', 'Branch.get_config_file'],
1281
[call.call.method for call in self.hpss_calls])
1284
1146
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1286
1148
def test_empty_branch(self):
1791
1652
branch.unlock()
1792
1653
self.assertFinished(client)
1794
def test_set_option_with_dict(self):
1795
client = FakeClient()
1796
client.add_expected_call(
1797
'Branch.get_stacked_on_url', ('memory:///',),
1798
'error', ('NotStacked',),)
1799
client.add_expected_call(
1800
'Branch.lock_write', ('memory:///', '', ''),
1801
'success', ('ok', 'branch token', 'repo token'))
1802
encoded_dict_value = 'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde'
1803
client.add_expected_call(
1804
'Branch.set_config_option_dict', ('memory:///', 'branch token',
1805
'repo token', encoded_dict_value, 'foo', ''),
1807
client.add_expected_call(
1808
'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
1810
transport = MemoryTransport()
1811
branch = self.make_remote_branch(transport, client)
1813
config = branch._get_config()
1815
{'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'},
1818
self.assertFinished(client)
1820
1655
def test_backwards_compat_set_option(self):
1821
1656
self.setup_smart_server_with_call_log()
1822
1657
branch = self.make_branch('.')
2274
2095
self.assertEqual({}, repo.get_parent_map(['non-existant']))
2275
2096
self.assertLength(0, self.hpss_calls)
2277
def test_exposes_get_cached_parent_map(self):
2278
"""RemoteRepository exposes get_cached_parent_map from
2281
r1 = u'\u0e33'.encode('utf8')
2282
r2 = u'\u0dab'.encode('utf8')
2283
lines = [' '.join([r2, r1]), r1]
2284
encoded_body = bz2.compress('\n'.join(lines))
2286
transport_path = 'quack'
2287
repo, client = self.setup_fake_client_and_repository(transport_path)
2288
client.add_success_response_with_body(encoded_body, 'ok')
2290
# get_cached_parent_map should *not* trigger an RPC
2291
self.assertEqual({}, repo.get_cached_parent_map([r1]))
2292
self.assertEqual([], client._calls)
2293
self.assertEqual({r2: (r1,)}, repo.get_parent_map([r2]))
2294
self.assertEqual({r1: (NULL_REVISION,)},
2295
repo.get_cached_parent_map([r1]))
2297
[('call_with_body_bytes_expecting_body',
2298
'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
2304
2099
class TestGetParentMapAllowsNew(tests.TestCaseWithTransport):
3125
2895
expected_error = errors.PermissionDenied(path, extra)
3126
2896
self.assertEqual(expected_error, translated_error)
3128
# GZ 2011-03-02: TODO test for PermissionDenied with non-ascii 'extra'
3130
def test_NoSuchFile_context_path(self):
3131
local_path = "local path"
3132
translated_error = self.translateTuple(('ReadError', "remote path"),
3134
expected_error = errors.ReadError(local_path)
3135
self.assertEqual(expected_error, translated_error)
3137
def test_NoSuchFile_without_context(self):
3138
remote_path = "remote path"
3139
translated_error = self.translateTuple(('ReadError', remote_path))
3140
expected_error = errors.ReadError(remote_path)
3141
self.assertEqual(expected_error, translated_error)
3143
def test_ReadOnlyError(self):
3144
translated_error = self.translateTuple(('ReadOnlyError',))
3145
expected_error = errors.TransportNotPossible("readonly transport")
3146
self.assertEqual(expected_error, translated_error)
3148
def test_MemoryError(self):
3149
translated_error = self.translateTuple(('MemoryError',))
3150
self.assertStartsWith(str(translated_error),
3151
"remote server out of memory")
3153
def test_generic_IndexError_no_classname(self):
3154
err = errors.ErrorFromSmartServer(('error', "list index out of range"))
3155
translated_error = self.translateErrorFromSmartServer(err)
3156
expected_error = errors.UnknownErrorFromSmartServer(err)
3157
self.assertEqual(expected_error, translated_error)
3159
# GZ 2011-03-02: TODO test generic non-ascii error string
3161
def test_generic_KeyError(self):
3162
err = errors.ErrorFromSmartServer(('error', 'KeyError', "1"))
3163
translated_error = self.translateErrorFromSmartServer(err)
3164
expected_error = errors.UnknownErrorFromSmartServer(err)
3165
self.assertEqual(expected_error, translated_error)
3168
2899
class TestErrorTranslationRobustness(TestErrorTranslationBase):
3169
2900
"""Unit tests for bzrlib.remote._translate_error's robustness.
3414
3143
def test_copy_content_into_avoids_revision_history(self):
3415
3144
local = self.make_branch('local')
3416
builder = self.make_branch_builder('remote')
3417
builder.build_commit(message="Commit.")
3145
remote_backing_tree = self.make_branch_and_tree('remote')
3146
remote_backing_tree.commit("Commit.")
3418
3147
remote_branch_url = self.smart_server.get_url() + 'remote'
3419
3148
remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3420
3149
local.repository.fetch(remote_branch.repository)
3421
3150
self.hpss_calls = []
3422
3151
remote_branch.copy_content_into(local)
3423
3152
self.assertFalse('Branch.revision_history' in self.hpss_calls)
3425
def test_fetch_everything_needs_just_one_call(self):
3426
local = self.make_branch('local')
3427
builder = self.make_branch_builder('remote')
3428
builder.build_commit(message="Commit.")
3429
remote_branch_url = self.smart_server.get_url() + 'remote'
3430
remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3431
self.hpss_calls = []
3432
local.repository.fetch(
3433
remote_branch.repository,
3434
fetch_spec=_mod_graph.EverythingResult(remote_branch.repository))
3435
self.assertEqual(['Repository.get_stream_1.19'], self.hpss_calls)
3437
def override_verb(self, verb_name, verb):
3438
request_handlers = request.request_handlers
3439
orig_verb = request_handlers.get(verb_name)
3440
request_handlers.register(verb_name, verb, override_existing=True)
3441
self.addCleanup(request_handlers.register, verb_name, orig_verb,
3442
override_existing=True)
3444
def test_fetch_everything_backwards_compat(self):
3445
"""Can fetch with EverythingResult even with pre 2.4 servers.
3447
Pre-2.4 do not support 'everything' searches with the
3448
Repository.get_stream_1.19 verb.
3451
class OldGetStreamVerb(SmartServerRepositoryGetStream_1_19):
3452
"""A version of the Repository.get_stream_1.19 verb patched to
3453
reject 'everything' searches the way 2.3 and earlier do.
3455
def recreate_search(self, repository, search_bytes,
3456
discard_excess=False):
3457
verb_log.append(search_bytes.split('\n', 1)[0])
3458
if search_bytes == 'everything':
3460
request.FailedSmartServerResponse(('BadSearch',)))
3461
return super(OldGetStreamVerb,
3462
self).recreate_search(repository, search_bytes,
3463
discard_excess=discard_excess)
3464
self.override_verb('Repository.get_stream_1.19', OldGetStreamVerb)
3465
local = self.make_branch('local')
3466
builder = self.make_branch_builder('remote')
3467
builder.build_commit(message="Commit.")
3468
remote_branch_url = self.smart_server.get_url() + 'remote'
3469
remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3470
self.hpss_calls = []
3471
local.repository.fetch(
3472
remote_branch.repository,
3473
fetch_spec=_mod_graph.EverythingResult(remote_branch.repository))
3474
# make sure the overridden verb was used
3475
self.assertLength(1, verb_log)
3476
# more than one HPSS call is needed, but because it's a VFS callback
3477
# its hard to predict exactly how many.
3478
self.assertTrue(len(self.hpss_calls) > 1)
3481
class TestUpdateBoundBranchWithModifiedBoundLocation(
3482
tests.TestCaseWithTransport):
3483
"""Ensure correct handling of bound_location modifications.
3485
This is tested against a smart server as http://pad.lv/786980 was about a
3486
ReadOnlyError (write attempt during a read-only transaction) which can only
3487
happen in this context.
3491
super(TestUpdateBoundBranchWithModifiedBoundLocation, self).setUp()
3492
self.transport_server = test_server.SmartTCPServer_for_testing
3494
def make_master_and_checkout(self, master_name, checkout_name):
3495
# Create the master branch and its associated checkout
3496
self.master = self.make_branch_and_tree(master_name)
3497
self.checkout = self.master.branch.create_checkout(checkout_name)
3498
# Modify the master branch so there is something to update
3499
self.master.commit('add stuff')
3500
self.last_revid = self.master.commit('even more stuff')
3501
self.bound_location = self.checkout.branch.get_bound_location()
3503
def assertUpdateSucceeds(self, new_location):
3504
self.checkout.branch.set_bound_location(new_location)
3505
self.checkout.update()
3506
self.assertEquals(self.last_revid, self.checkout.last_revision())
3508
def test_without_final_slash(self):
3509
self.make_master_and_checkout('master', 'checkout')
3510
# For unclear reasons some users have a bound_location without a final
3511
# '/', simulate that by forcing such a value
3512
self.assertEndsWith(self.bound_location, '/')
3513
self.assertUpdateSucceeds(self.bound_location.rstrip('/'))
3515
def test_plus_sign(self):
3516
self.make_master_and_checkout('+master', 'checkout')
3517
self.assertUpdateSucceeds(self.bound_location.replace('%2B', '+', 1))
3519
def test_tilda(self):
3520
# Embed ~ in the middle of the path just to avoid any $HOME
3522
self.make_master_and_checkout('mas~ter', 'checkout')
3523
self.assertUpdateSucceeds(self.bound_location.replace('%2E', '~', 1))
added
removed
bzrlib/tests/test_remote.py
