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)
419
418
# Calling _remember_remote_is_before again with a lower value works.
420
419
client_medium._remember_remote_is_before((1, 5))
421
420
self.assertTrue(client_medium._is_remote_before((1, 5)))
422
# If you call _remember_remote_is_before with a higher value it logs a
423
# warning, and continues to remember the lower value.
424
self.assertNotContainsRe(self.get_log(), '_remember_remote_is_before')
425
client_medium._remember_remote_is_before((1, 9))
426
self.assertContainsRe(self.get_log(), '_remember_remote_is_before')
427
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))
430
426
class TestBzrDirCloningMetaDir(TestRemote):
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(),
531
_client=client, _force_probe=True)
532
self.assertIsInstance(bd, RemoteBzrDir)
533
self.assertFinished(client)
535
def test_backwards_compat_hpss_v2(self):
536
client, transport = self.make_fake_client_and_transport()
537
# Monkey-patch fake client to simulate real-world behaviour with v2
538
# server: upon first RPC call detect the protocol version, and because
539
# the version is 2 also do _remember_remote_is_before((1, 6)) before
540
# continuing with the RPC.
541
orig_check_call = client._check_call
542
def check_call(method, args):
543
client._medium._protocol_version = 2
544
client._medium._remember_remote_is_before((1, 6))
545
client._check_call = orig_check_call
546
client._check_call(method, args)
547
client._check_call = check_call
548
client.add_expected_call(
549
'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
550
client.add_expected_call(
551
'BzrDir.open', ('quack/',), 'success', ('yes',))
552
bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
526
bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
553
527
_client=client, _force_probe=True)
554
528
self.assertIsInstance(bd, RemoteBzrDir)
555
529
self.assertFinished(client)
610
584
# _get_tree_branch is a form of open_branch, but it should only ask for
611
585
# branch opening, not any other network requests.
613
def open_branch(name=None):
614
588
calls.append("Called")
615
589
return "a-branch"
616
590
transport = MemoryTransport()
617
591
# no requests on the network - catches other api calls being made.
618
592
client = FakeClient(transport.base)
619
bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
593
bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
621
595
# patch the open_branch call to record that it was called.
622
596
bzrdir.open_branch = open_branch
725
699
format = branch._format
726
700
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
703
class TestBzrDirCreateRepository(TestRemote):
1172
1118
[('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
1121
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1242
1123
def test_empty_branch(self):
1354
1235
'success', ('branch', branch_network_name))
1355
1236
client.add_expected_call(
1356
1237
'BzrDir.find_repositoryV3', ('stacked/',),
1357
'success', ('ok', '', 'yes', 'no', 'yes', network_name))
1238
'success', ('ok', '', 'no', 'no', 'yes', network_name))
1358
1239
# called twice, once from constructor and then again by us
1359
1240
client.add_expected_call(
1360
1241
'Branch.get_stacked_on_url', ('stacked/',),
1405
1286
# unnecessarily invokes _ensure_real upon a call to lock_write.
1406
1287
branch._ensure_real = lambda: None
1407
1288
branch.lock_write()
1408
result = branch._set_last_revision(NULL_REVISION)
1289
result = branch.set_revision_history([])
1409
1290
branch.unlock()
1410
1291
self.assertEqual(None, result)
1411
1292
self.assertFinished(client)
1413
1294
def test_set_nonempty(self):
1414
# set_last_revision_info(N, rev-idN) is translated to calling
1295
# set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
1415
1296
# Branch.set_last_revision(path, rev-idN) on the wire.
1416
1297
transport = MemoryTransport()
1417
1298
transport.mkdir('branch')
1747
1627
branch.unlock()
1748
1628
self.assertFinished(client)
1750
def test_set_option_with_dict(self):
1751
client = FakeClient()
1752
client.add_expected_call(
1753
'Branch.get_stacked_on_url', ('memory:///',),
1754
'error', ('NotStacked',),)
1755
client.add_expected_call(
1756
'Branch.lock_write', ('memory:///', '', ''),
1757
'success', ('ok', 'branch token', 'repo token'))
1758
encoded_dict_value = 'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde'
1759
client.add_expected_call(
1760
'Branch.set_config_option_dict', ('memory:///', 'branch token',
1761
'repo token', encoded_dict_value, 'foo', ''),
1763
client.add_expected_call(
1764
'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
1766
transport = MemoryTransport()
1767
branch = self.make_remote_branch(transport, client)
1769
config = branch._get_config()
1771
{'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'},
1774
self.assertFinished(client)
1776
1630
def test_backwards_compat_set_option(self):
1777
1631
self.setup_smart_server_with_call_log()
1778
1632
branch = self.make_branch('.')
1785
1639
self.assertLength(10, self.hpss_calls)
1786
1640
self.assertEqual('value', branch._get_config().get_option('name'))
1788
def test_backwards_compat_set_option_with_dict(self):
1789
self.setup_smart_server_with_call_log()
1790
branch = self.make_branch('.')
1791
verb = 'Branch.set_config_option_dict'
1792
self.disable_verb(verb)
1794
self.addCleanup(branch.unlock)
1795
self.reset_smart_call_log()
1796
config = branch._get_config()
1797
value_dict = {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
1798
config.set_option(value_dict, 'name')
1799
self.assertLength(10, self.hpss_calls)
1800
self.assertEqual(value_dict, branch._get_config().get_option('name'))
1803
1643
class TestBranchLockWrite(RemoteBranchTestCase):
1963
1803
class TestRepositoryFormat(TestRemoteRepository):
1965
1805
def test_fast_delta(self):
1966
true_name = groupcompress_repo.RepositoryFormat2a().network_name()
1806
true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
1967
1807
true_format = RemoteRepositoryFormat()
1968
1808
true_format._network_name = true_name
1969
1809
self.assertEqual(True, true_format.fast_deltas)
1970
false_name = knitpack_repo.RepositoryFormatKnitPack1().network_name()
1810
false_name = pack_repo.RepositoryFormatKnitPack1().network_name()
1971
1811
false_format = RemoteRepositoryFormat()
1972
1812
false_format._network_name = false_name
1973
1813
self.assertEqual(False, false_format.fast_deltas)
1975
1815
def test_get_format_description(self):
1976
1816
remote_repo_format = RemoteRepositoryFormat()
1977
real_format = repository.format_registry.get_default()
1817
real_format = repository.RepositoryFormat.get_default_format()
1978
1818
remote_repo_format._network_name = real_format.network_name()
1979
1819
self.assertEqual(remoted_description(real_format),
1980
1820
remote_repo_format.get_format_description())
2352
2192
# Make a repo with a fallback repo, both using a FakeClient.
2353
2193
format = remote.response_tuple_to_repo_format(
2354
('yes', 'no', 'yes', self.get_repo_format().network_name()))
2194
('yes', 'no', 'yes', 'fake-network-name'))
2355
2195
repo, client = self.setup_fake_client_and_repository('quack')
2356
2196
repo._format = format
2357
2197
fallback_repo, ignored = self.setup_fake_client_and_repository(
2359
2199
fallback_repo._client = client
2360
fallback_repo._format = format
2361
2200
repo.add_fallback_repository(fallback_repo)
2362
2201
# First the client should ask the primary repo
2363
2202
client.add_expected_call(
2870
2708
('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
2712
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
2885
2713
"""Base class for unit tests for bzrlib.remote._translate_error."""
2998
2819
expected_error = errors.DivergedBranches(branch, other_branch)
2999
2820
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
2822
def test_ReadError_no_args(self):
3008
2823
path = 'a path'
3009
2824
translated_error = self.translateTuple(('ReadError',), path=path)
3055
2869
expected_error = errors.PermissionDenied(path, extra)
3056
2870
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
2873
class TestErrorTranslationRobustness(TestErrorTranslationBase):
3099
2874
"""Unit tests for bzrlib.remote._translate_error's robustness.
3244
3019
_, stacked = branch_factory()
3245
3020
source = stacked.repository._get_source(target_repository_format)
3246
3021
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)
3022
revs = stacked.repository.get_ancestry(tip)
3023
search = graph.PendingAncestryResult([tip], stacked.repository)
3253
3024
self.reset_smart_call_log()
3254
3025
stream = source.get_stream(search)
3255
3028
# We trust that if a revision is in the stream the rest of the new
3256
3029
# content for it is too, as per our main fetch tests; here we are
3257
3030
# checking that the revisions are actually included at all, and their
3344
3117
def test_copy_content_into_avoids_revision_history(self):
3345
3118
local = self.make_branch('local')
3346
builder = self.make_branch_builder('remote')
3347
builder.build_commit(message="Commit.")
3119
remote_backing_tree = self.make_branch_and_tree('remote')
3120
remote_backing_tree.commit("Commit.")
3348
3121
remote_branch_url = self.smart_server.get_url() + 'remote'
3349
3122
remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3350
3123
local.repository.fetch(remote_branch.repository)
3351
3124
self.hpss_calls = []
3352
3125
remote_branch.copy_content_into(local)
3353
3126
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
