31
31
from bzrlib import (
33
branch as _mod_branch,
42
from bzrlib.smart import (
43
branch as smart_branch,
45
repository as smart_repo,
46
packrepository as smart_packrepo,
51
from bzrlib.tests import test_server
52
from bzrlib.transport import (
39
from bzrlib.branch import Branch, BranchReferenceFormat
40
import bzrlib.smart.branch
41
import bzrlib.smart.bzrdir, bzrlib.smart.bzrdir as smart_dir
42
import bzrlib.smart.packrepository
43
import bzrlib.smart.repository
44
from bzrlib.smart.request import (
45
FailedSmartServerResponse,
48
SuccessfulSmartServerResponse,
50
from bzrlib.tests import (
55
from bzrlib.transport import chroot, get_transport
56
from bzrlib.util import bencode
58
59
def load_tests(standard_tests, module, loader):
59
60
"""Multiply tests version and protocol consistency."""
60
61
# FindRepository tests.
62
bzrdir_mod = bzrlib.smart.bzrdir
63
applier = TestScenarioApplier()
62
65
("find_repository", {
63
"_request_class": smart_dir.SmartServerRequestFindRepositoryV1}),
66
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV1}),
64
67
("find_repositoryV2", {
65
"_request_class": smart_dir.SmartServerRequestFindRepositoryV2}),
68
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV2}),
66
69
("find_repositoryV3", {
67
"_request_class": smart_dir.SmartServerRequestFindRepositoryV3}),
70
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV3}),
69
to_adapt, result = tests.split_suite_by_re(standard_tests,
72
to_adapt, result = split_suite_by_re(standard_tests,
70
73
"TestSmartServerRequestFindRepository")
71
v2_only, v1_and_2 = tests.split_suite_by_re(to_adapt,
74
v2_only, v1_and_2 = split_suite_by_re(to_adapt,
73
tests.multiply_tests(v1_and_2, scenarios, result)
74
# The first scenario is only applicable to v1 protocols, it is deleted
76
tests.multiply_tests(v2_only, scenarios[1:], result)
76
for test in iter_suite_tests(v1_and_2):
77
result.addTests(applier.adapt(test))
78
del applier.scenarios[0]
79
for test in iter_suite_tests(v2_only):
80
result.addTests(applier.adapt(test))
80
84
class TestCaseWithChrootedTransport(tests.TestCaseWithTransport):
83
self.vfs_transport_factory = memory.MemoryServer
84
87
tests.TestCaseWithTransport.setUp(self)
85
88
self._chroot_server = None
106
110
self.transport_server = self.make_transport_server
108
112
def make_transport_server(self):
109
return test_server.SmartTCPServer_for_testing('-' + self.id())
113
return smart.server.SmartTCPServer_for_testing('-' + self.id())
111
115
def get_smart_medium(self):
112
116
"""Get a smart medium to use in tests."""
113
117
return self.get_transport().get_smart_medium()
116
class TestByteStreamToStream(tests.TestCase):
118
def test_repeated_substreams_same_kind_are_one_stream(self):
119
# Make a stream - an iterable of bytestrings.
120
stream = [('text', [versionedfile.FulltextContentFactory(('k1',), None,
121
None, 'foo')]),('text', [
122
versionedfile.FulltextContentFactory(('k2',), None, None, 'bar')])]
123
fmt = bzrdir.format_registry.get('pack-0.92')().repository_format
124
bytes = smart_repo._stream_to_byte_stream(stream, fmt)
126
# Iterate the resulting iterable; checking that we get only one stream
128
fmt, stream = smart_repo._byte_stream_to_stream(bytes)
129
for kind, substream in stream:
130
streams.append((kind, list(substream)))
131
self.assertLength(1, streams)
132
self.assertLength(2, streams[0][1])
135
120
class TestSmartServerResponse(tests.TestCase):
137
122
def test__eq__(self):
138
self.assertEqual(smart_req.SmartServerResponse(('ok', )),
139
smart_req.SmartServerResponse(('ok', )))
140
self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'body'),
141
smart_req.SmartServerResponse(('ok', ), 'body'))
142
self.assertNotEqual(smart_req.SmartServerResponse(('ok', )),
143
smart_req.SmartServerResponse(('notok', )))
144
self.assertNotEqual(smart_req.SmartServerResponse(('ok', ), 'body'),
145
smart_req.SmartServerResponse(('ok', )))
123
self.assertEqual(SmartServerResponse(('ok', )),
124
SmartServerResponse(('ok', )))
125
self.assertEqual(SmartServerResponse(('ok', ), 'body'),
126
SmartServerResponse(('ok', ), 'body'))
127
self.assertNotEqual(SmartServerResponse(('ok', )),
128
SmartServerResponse(('notok', )))
129
self.assertNotEqual(SmartServerResponse(('ok', ), 'body'),
130
SmartServerResponse(('ok', )))
146
131
self.assertNotEqual(None,
147
smart_req.SmartServerResponse(('ok', )))
132
SmartServerResponse(('ok', )))
149
134
def test__str__(self):
150
135
"""SmartServerResponses can be stringified."""
151
136
self.assertEqual(
152
137
"<SuccessfulSmartServerResponse args=('args',) body='body'>",
153
str(smart_req.SuccessfulSmartServerResponse(('args',), 'body')))
138
str(SuccessfulSmartServerResponse(('args',), 'body')))
154
139
self.assertEqual(
155
140
"<FailedSmartServerResponse args=('args',) body='body'>",
156
str(smart_req.FailedSmartServerResponse(('args',), 'body')))
141
str(FailedSmartServerResponse(('args',), 'body')))
159
144
class TestSmartServerRequest(tests.TestCaseWithMemoryTransport):
161
146
def test_translate_client_path(self):
162
147
transport = self.get_transport()
163
request = smart_req.SmartServerRequest(transport, 'foo/')
148
request = SmartServerRequest(transport, 'foo/')
164
149
self.assertEqual('./', request.translate_client_path('foo/'))
165
150
self.assertRaises(
166
151
errors.InvalidURLJoin, request.translate_client_path, 'foo/..')
201
174
local_result = dir.cloning_metadir()
202
175
request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
203
176
request = request_class(backing)
204
expected = smart_req.SuccessfulSmartServerResponse(
177
expected = SuccessfulSmartServerResponse(
205
178
(local_result.network_name(),
206
179
local_result.repository_format.network_name(),
207
180
('branch', local_result.get_branch_format().network_name())))
208
181
self.assertEqual(expected, request.execute('', 'False'))
210
183
def test_cloning_metadir_reference(self):
211
"""The request fails when bzrdir contains a branch reference."""
184
"""The request works when bzrdir contains a branch reference."""
212
185
backing = self.get_transport()
213
186
referenced_branch = self.make_branch('referenced')
214
187
dir = self.make_bzrdir('.')
215
188
local_result = dir.cloning_metadir()
216
reference = _mod_branch.BranchReferenceFormat().initialize(
217
dir, target_branch=referenced_branch)
218
reference_url = _mod_branch.BranchReferenceFormat().get_reference(dir)
189
reference = BranchReferenceFormat().initialize(dir, referenced_branch)
190
reference_url = BranchReferenceFormat().get_reference(dir)
219
191
# The server shouldn't try to follow the branch reference, so it's fine
220
192
# if the referenced branch isn't reachable.
221
193
backing.rename('referenced', 'moved')
222
194
request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
223
195
request = request_class(backing)
224
expected = smart_req.FailedSmartServerResponse(('BranchReference',))
196
expected = SuccessfulSmartServerResponse(
197
(local_result.network_name(),
198
local_result.repository_format.network_name(),
199
('ref', reference_url)))
225
200
self.assertEqual(expected, request.execute('', 'False'))
282
if repo._format.supports_external_lookups:
286
if (smart_dir.SmartServerRequestFindRepositoryV3 ==
257
if (smart.bzrdir.SmartServerRequestFindRepositoryV3 ==
287
258
self._request_class):
288
return smart_req.SuccessfulSmartServerResponse(
289
('ok', '', rich_root, subtrees, external,
259
return SuccessfulSmartServerResponse(
260
('ok', '', rich_root, subtrees, 'no',
290
261
repo._format.network_name()))
291
elif (smart_dir.SmartServerRequestFindRepositoryV2 ==
262
elif (smart.bzrdir.SmartServerRequestFindRepositoryV2 ==
292
263
self._request_class):
293
264
# All tests so far are on formats, and for non-external
295
return smart_req.SuccessfulSmartServerResponse(
296
('ok', '', rich_root, subtrees, external))
266
return SuccessfulSmartServerResponse(
267
('ok', '', rich_root, subtrees, 'no'))
298
return smart_req.SuccessfulSmartServerResponse(
299
('ok', '', rich_root, subtrees))
269
return SuccessfulSmartServerResponse(('ok', '', rich_root, subtrees))
301
271
def test_shared_repository(self):
302
272
"""When there is a shared repository, we get 'ok', 'relpath-to-repo'."""
330
297
"""Test for the supports_external_lookups attribute."""
331
298
backing = self.get_transport()
332
299
request = self._request_class(backing)
333
result = self._make_repository_and_result(
334
format='dirstate-with-subtree')
300
result = self._make_repository_and_result(format='dirstate-with-subtree')
335
301
# check the test will be valid
336
302
self.assertEqual('no', result.args[4])
337
303
self.assertEqual(result, request.execute(''))
340
class TestSmartServerBzrDirRequestGetConfigFile(
341
tests.TestCaseWithMemoryTransport):
342
"""Tests for BzrDir.get_config_file."""
344
def test_present(self):
345
backing = self.get_transport()
346
dir = self.make_bzrdir('.')
347
dir.get_config().set_default_stack_on("/")
348
local_result = dir._get_config()._get_config_file().read()
349
request_class = smart_dir.SmartServerBzrDirRequestConfigFile
350
request = request_class(backing)
351
expected = smart_req.SuccessfulSmartServerResponse((), local_result)
352
self.assertEqual(expected, request.execute(''))
354
def test_missing(self):
355
backing = self.get_transport()
356
dir = self.make_bzrdir('.')
357
request_class = smart_dir.SmartServerBzrDirRequestConfigFile
358
request = request_class(backing)
359
expected = smart_req.SuccessfulSmartServerResponse((), '')
360
self.assertEqual(expected, request.execute(''))
363
306
class TestSmartServerRequestInitializeBzrDir(tests.TestCaseWithMemoryTransport):
365
308
def test_empty_dir(self):
366
309
"""Initializing an empty dir should succeed and do it."""
367
310
backing = self.get_transport()
368
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
369
self.assertEqual(smart_req.SmartServerResponse(('ok', )),
311
request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
312
self.assertEqual(SmartServerResponse(('ok', )),
370
313
request.execute(''))
371
314
made_dir = bzrdir.BzrDir.open_from_transport(backing)
372
315
# no branch, tree or repository is expected with the current
378
321
def test_missing_dir(self):
379
322
"""Initializing a missing directory should fail like the bzrdir api."""
380
323
backing = self.get_transport()
381
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
324
request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
382
325
self.assertRaises(errors.NoSuchFile,
383
326
request.execute, 'subdir')
385
328
def test_initialized_dir(self):
386
329
"""Initializing an extant bzrdir should fail like the bzrdir api."""
387
330
backing = self.get_transport()
388
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
331
request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
389
332
self.make_bzrdir('subdir')
390
333
self.assertRaises(errors.FileExists,
391
334
request.execute, 'subdir')
394
class TestSmartServerRequestBzrDirInitializeEx(
395
tests.TestCaseWithMemoryTransport):
396
"""Basic tests for BzrDir.initialize_ex_1.16 in the smart server.
398
The main unit tests in test_bzrdir exercise the API comprehensively.
401
def test_empty_dir(self):
402
"""Initializing an empty dir should succeed and do it."""
403
backing = self.get_transport()
404
name = self.make_bzrdir('reference')._format.network_name()
405
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
407
smart_req.SmartServerResponse(('', '', '', '', '', '', name,
408
'False', '', '', '')),
409
request.execute(name, '', 'True', 'False', 'False', '', '', '', '',
411
made_dir = bzrdir.BzrDir.open_from_transport(backing)
412
# no branch, tree or repository is expected with the current
414
self.assertRaises(errors.NoWorkingTree, made_dir.open_workingtree)
415
self.assertRaises(errors.NotBranchError, made_dir.open_branch)
416
self.assertRaises(errors.NoRepositoryPresent, made_dir.open_repository)
418
def test_missing_dir(self):
419
"""Initializing a missing directory should fail like the bzrdir api."""
420
backing = self.get_transport()
421
name = self.make_bzrdir('reference')._format.network_name()
422
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
423
self.assertRaises(errors.NoSuchFile, request.execute, name,
424
'subdir/dir', 'False', 'False', 'False', '', '', '', '', 'False')
426
def test_initialized_dir(self):
427
"""Initializing an extant directory should fail like the bzrdir api."""
428
backing = self.get_transport()
429
name = self.make_bzrdir('reference')._format.network_name()
430
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
431
self.make_bzrdir('subdir')
432
self.assertRaises(errors.FileExists, request.execute, name, 'subdir',
433
'False', 'False', 'False', '', '', '', '', 'False')
436
class TestSmartServerRequestOpenBzrDir(tests.TestCaseWithMemoryTransport):
438
def test_no_directory(self):
439
backing = self.get_transport()
440
request = smart_dir.SmartServerRequestOpenBzrDir(backing)
441
self.assertEqual(smart_req.SmartServerResponse(('no', )),
442
request.execute('does-not-exist'))
444
def test_empty_directory(self):
445
backing = self.get_transport()
446
backing.mkdir('empty')
447
request = smart_dir.SmartServerRequestOpenBzrDir(backing)
448
self.assertEqual(smart_req.SmartServerResponse(('no', )),
449
request.execute('empty'))
451
def test_outside_root_client_path(self):
452
backing = self.get_transport()
453
request = smart_dir.SmartServerRequestOpenBzrDir(backing,
454
root_client_path='root')
455
self.assertEqual(smart_req.SmartServerResponse(('no', )),
456
request.execute('not-root'))
459
class TestSmartServerRequestOpenBzrDir_2_1(tests.TestCaseWithMemoryTransport):
461
def test_no_directory(self):
462
backing = self.get_transport()
463
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
464
self.assertEqual(smart_req.SmartServerResponse(('no', )),
465
request.execute('does-not-exist'))
467
def test_empty_directory(self):
468
backing = self.get_transport()
469
backing.mkdir('empty')
470
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
471
self.assertEqual(smart_req.SmartServerResponse(('no', )),
472
request.execute('empty'))
474
def test_present_without_workingtree(self):
475
backing = self.get_transport()
476
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
477
self.make_bzrdir('.')
478
self.assertEqual(smart_req.SmartServerResponse(('yes', 'no')),
481
def test_outside_root_client_path(self):
482
backing = self.get_transport()
483
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing,
484
root_client_path='root')
485
self.assertEqual(smart_req.SmartServerResponse(('no',)),
486
request.execute('not-root'))
489
class TestSmartServerRequestOpenBzrDir_2_1_disk(TestCaseWithChrootedTransport):
491
def test_present_with_workingtree(self):
492
self.vfs_transport_factory = test_server.LocalURLServer
493
backing = self.get_transport()
494
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
495
bd = self.make_bzrdir('.')
496
bd.create_repository()
498
bd.create_workingtree()
499
self.assertEqual(smart_req.SmartServerResponse(('yes', 'yes')),
503
337
class TestSmartServerRequestOpenBranch(TestCaseWithChrootedTransport):
505
339
def test_no_branch(self):
506
340
"""When there is no branch, ('nobranch', ) is returned."""
507
341
backing = self.get_transport()
508
request = smart_dir.SmartServerRequestOpenBranch(backing)
342
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
509
343
self.make_bzrdir('.')
510
self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
344
self.assertEqual(SmartServerResponse(('nobranch', )),
511
345
request.execute(''))
513
347
def test_branch(self):
514
348
"""When there is a branch, 'ok' is returned."""
515
349
backing = self.get_transport()
516
request = smart_dir.SmartServerRequestOpenBranch(backing)
350
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
517
351
self.make_branch('.')
518
self.assertEqual(smart_req.SmartServerResponse(('ok', '')),
352
self.assertEqual(SmartServerResponse(('ok', '')),
519
353
request.execute(''))
521
355
def test_branch_reference(self):
522
356
"""When there is a branch reference, the reference URL is returned."""
523
self.vfs_transport_factory = test_server.LocalURLServer
524
357
backing = self.get_transport()
525
request = smart_dir.SmartServerRequestOpenBranch(backing)
358
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
526
359
branch = self.make_branch('branch')
527
360
checkout = branch.create_checkout('reference',lightweight=True)
528
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
361
reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
530
362
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
531
self.assertEqual(smart_req.SmartServerResponse(('ok', reference_url)),
363
self.assertEqual(SmartServerResponse(('ok', reference_url)),
532
364
request.execute('reference'))
534
def test_notification_on_branch_from_repository(self):
535
"""When there is a repository, the error should return details."""
536
backing = self.get_transport()
537
request = smart_dir.SmartServerRequestOpenBranch(backing)
538
repo = self.make_repository('.')
539
self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
543
367
class TestSmartServerRequestOpenBranchV2(TestCaseWithChrootedTransport):
546
370
"""When there is no branch, ('nobranch', ) is returned."""
547
371
backing = self.get_transport()
548
372
self.make_bzrdir('.')
549
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
550
self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
553
def test_branch(self):
554
"""When there is a branch, 'ok' is returned."""
555
backing = self.get_transport()
556
expected = self.make_branch('.')._format.network_name()
557
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
558
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
559
('branch', expected)),
562
def test_branch_reference(self):
563
"""When there is a branch reference, the reference URL is returned."""
564
self.vfs_transport_factory = test_server.LocalURLServer
565
backing = self.get_transport()
566
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
567
branch = self.make_branch('branch')
568
checkout = branch.create_checkout('reference',lightweight=True)
569
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
571
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
572
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
573
('ref', reference_url)),
574
request.execute('reference'))
576
def test_stacked_branch(self):
577
"""Opening a stacked branch does not open the stacked-on branch."""
578
trunk = self.make_branch('trunk')
579
feature = self.make_branch('feature')
580
feature.set_stacked_on_url(trunk.base)
582
_mod_branch.Branch.hooks.install_named_hook(
583
'open', opened_branches.append, None)
584
backing = self.get_transport()
585
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
588
response = request.execute('feature')
590
request.teardown_jail()
591
expected_format = feature._format.network_name()
592
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
593
('branch', expected_format)),
595
self.assertLength(1, opened_branches)
597
def test_notification_on_branch_from_repository(self):
598
"""When there is a repository, the error should return details."""
599
backing = self.get_transport()
600
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
601
repo = self.make_repository('.')
602
self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
606
class TestSmartServerRequestOpenBranchV3(TestCaseWithChrootedTransport):
608
def test_no_branch(self):
609
"""When there is no branch, ('nobranch', ) is returned."""
610
backing = self.get_transport()
611
self.make_bzrdir('.')
612
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
613
self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
616
def test_branch(self):
617
"""When there is a branch, 'ok' is returned."""
618
backing = self.get_transport()
619
expected = self.make_branch('.')._format.network_name()
620
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
621
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
622
('branch', expected)),
625
def test_branch_reference(self):
626
"""When there is a branch reference, the reference URL is returned."""
627
self.vfs_transport_factory = test_server.LocalURLServer
628
backing = self.get_transport()
629
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
630
branch = self.make_branch('branch')
631
checkout = branch.create_checkout('reference',lightweight=True)
632
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
634
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
635
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
636
('ref', reference_url)),
637
request.execute('reference'))
639
def test_stacked_branch(self):
640
"""Opening a stacked branch does not open the stacked-on branch."""
641
trunk = self.make_branch('trunk')
642
feature = self.make_branch('feature')
643
feature.set_stacked_on_url(trunk.base)
645
_mod_branch.Branch.hooks.install_named_hook(
646
'open', opened_branches.append, None)
647
backing = self.get_transport()
648
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
651
response = request.execute('feature')
653
request.teardown_jail()
654
expected_format = feature._format.network_name()
655
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
656
('branch', expected_format)),
658
self.assertLength(1, opened_branches)
660
def test_notification_on_branch_from_repository(self):
661
"""When there is a repository, the error should return details."""
662
backing = self.get_transport()
663
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
664
repo = self.make_repository('.')
665
self.assertEqual(smart_req.SmartServerResponse(
666
('nobranch', 'location is a repository')),
373
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
374
self.assertEqual(SmartServerResponse(('nobranch', )),
377
def test_branch(self):
378
"""When there is a branch, 'ok' is returned."""
379
backing = self.get_transport()
380
expected = self.make_branch('.')._format.network_name()
381
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
382
self.assertEqual(SuccessfulSmartServerResponse(('branch', expected)),
385
def test_branch_reference(self):
386
"""When there is a branch reference, the reference URL is returned."""
387
backing = self.get_transport()
388
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
389
branch = self.make_branch('branch')
390
checkout = branch.create_checkout('reference',lightweight=True)
391
reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
392
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
393
self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
394
request.execute('reference'))
670
397
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
705
432
def test_branch_reference(self):
706
433
"""When there is a branch reference, NotBranchError is raised."""
707
434
backing = self.get_transport()
708
request = smart_branch.SmartServerBranchRequest(backing)
435
request = smart.branch.SmartServerBranchRequest(backing)
709
436
branch = self.make_branch('branch')
710
437
checkout = branch.create_checkout('reference',lightweight=True)
711
438
self.assertRaises(errors.NotBranchError,
712
439
request.execute, 'checkout')
715
class TestSmartServerBranchRequestLastRevisionInfo(
716
tests.TestCaseWithMemoryTransport):
442
class TestSmartServerBranchRequestLastRevisionInfo(tests.TestCaseWithMemoryTransport):
718
444
def test_empty(self):
719
445
"""For an empty branch, the result is ('ok', '0', 'null:')."""
720
446
backing = self.get_transport()
721
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
447
request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
722
448
self.make_branch('.')
723
self.assertEqual(smart_req.SmartServerResponse(('ok', '0', 'null:')),
449
self.assertEqual(SmartServerResponse(('ok', '0', 'null:')),
724
450
request.execute(''))
726
452
def test_not_empty(self):
727
453
"""For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
728
454
backing = self.get_transport()
729
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
455
request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
730
456
tree = self.make_branch_and_memory_tree('.')
731
457
tree.lock_write()
757
482
# branch.control_files.get('branch.conf') for now - in the future it may
758
483
# perform more complex processing.
759
484
backing = self.get_transport()
760
request = smart_branch.SmartServerBranchGetConfigFile(backing)
485
request = smart.branch.SmartServerBranchGetConfigFile(backing)
761
486
branch = self.make_branch('.')
762
487
branch._transport.put_bytes('branch.conf', 'foo bar baz')
763
self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'foo bar baz'),
488
self.assertEqual(SmartServerResponse(('ok', ), 'foo bar baz'),
764
489
request.execute(''))
767
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
769
def get_lock_tokens(self, branch):
770
branch_token = branch.lock_write()
771
repo_token = branch.repository.lock_write()
772
branch.repository.unlock()
773
return branch_token, repo_token
776
class TestSmartServerBranchRequestSetConfigOption(TestLockedBranch):
778
def test_value_name(self):
779
branch = self.make_branch('.')
780
request = smart_branch.SmartServerBranchRequestSetConfigOption(
781
branch.bzrdir.root_transport)
782
branch_token, repo_token = self.get_lock_tokens(branch)
783
config = branch._get_config()
784
result = request.execute('', branch_token, repo_token, 'bar', 'foo',
786
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
787
self.assertEqual('bar', config.get_option('foo'))
791
def test_value_name_section(self):
792
branch = self.make_branch('.')
793
request = smart_branch.SmartServerBranchRequestSetConfigOption(
794
branch.bzrdir.root_transport)
795
branch_token, repo_token = self.get_lock_tokens(branch)
796
config = branch._get_config()
797
result = request.execute('', branch_token, repo_token, 'bar', 'foo',
799
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
800
self.assertEqual('bar', config.get_option('foo', 'gam'))
805
class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):
806
# Only called when the branch format and tags match [yay factory
807
# methods] so only need to test straight forward cases.
809
def test_set_bytes(self):
810
base_branch = self.make_branch('base')
811
tag_bytes = base_branch._get_tags_bytes()
812
# get_lock_tokens takes out a lock.
813
branch_token, repo_token = self.get_lock_tokens(base_branch)
814
request = smart_branch.SmartServerBranchSetTagsBytes(
815
self.get_transport())
816
response = request.execute('base', branch_token, repo_token)
817
self.assertEqual(None, response)
818
response = request.do_chunk(tag_bytes)
819
self.assertEqual(None, response)
820
response = request.do_end()
822
smart_req.SuccessfulSmartServerResponse(()), response)
825
def test_lock_failed(self):
826
base_branch = self.make_branch('base')
827
base_branch.lock_write()
828
tag_bytes = base_branch._get_tags_bytes()
829
request = smart_branch.SmartServerBranchSetTagsBytes(
830
self.get_transport())
831
self.assertRaises(errors.TokenMismatch, request.execute,
832
'base', 'wrong token', 'wrong token')
833
# The request handler will keep processing the message parts, so even
834
# if the request fails immediately do_chunk and do_end are still
836
request.do_chunk(tag_bytes)
842
class SetLastRevisionTestBase(TestLockedBranch):
492
class SetLastRevisionTestBase(tests.TestCaseWithMemoryTransport):
843
493
"""Base test case for verbs that implement set_last_revision."""
1059
712
def test_get_parent_none(self):
1060
713
base_branch = self.make_branch('base')
1061
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
714
request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1062
715
response = request.execute('base')
1063
716
self.assertEquals(
1064
smart_req.SuccessfulSmartServerResponse(('',)), response)
717
SuccessfulSmartServerResponse(('',)), response)
1066
719
def test_get_parent_something(self):
1067
720
base_branch = self.make_branch('base')
1068
721
base_branch.set_parent(self.get_url('foo'))
1069
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
722
request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1070
723
response = request.execute('base')
1071
724
self.assertEquals(
1072
smart_req.SuccessfulSmartServerResponse(("../foo",)),
725
SuccessfulSmartServerResponse(("../foo",)),
1076
class TestSmartServerBranchRequestSetParent(tests.TestCaseWithMemoryTransport):
1078
def test_set_parent_none(self):
1079
branch = self.make_branch('base', format="1.9")
1081
branch._set_parent_location('foo')
1083
request = smart_branch.SmartServerBranchRequestSetParentLocation(
1084
self.get_transport())
1085
branch_token = branch.lock_write()
1086
repo_token = branch.repository.lock_write()
1088
response = request.execute('base', branch_token, repo_token, '')
1090
branch.repository.unlock()
1092
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1093
self.assertEqual(None, branch.get_parent())
1095
def test_set_parent_something(self):
1096
branch = self.make_branch('base', format="1.9")
1097
request = smart_branch.SmartServerBranchRequestSetParentLocation(
1098
self.get_transport())
1099
branch_token = branch.lock_write()
1100
repo_token = branch.repository.lock_write()
1102
response = request.execute('base', branch_token, repo_token,
1105
branch.repository.unlock()
1107
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1108
self.assertEqual('http://bar/', branch.get_parent())
1111
class TestSmartServerBranchRequestGetTagsBytes(
1112
tests.TestCaseWithMemoryTransport):
1113
# Only called when the branch format and tags match [yay factory
1114
# methods] so only need to test straight forward cases.
729
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
730
# Only called when the branch format and tags match [yay factory
731
# methods] so only need to test straight forward cases.
1116
733
def test_get_bytes(self):
1117
734
base_branch = self.make_branch('base')
1118
request = smart_branch.SmartServerBranchGetTagsBytes(
735
request = smart.branch.SmartServerBranchGetTagsBytes(
1119
736
self.get_transport())
1120
737
response = request.execute('base')
1121
738
self.assertEquals(
1122
smart_req.SuccessfulSmartServerResponse(('',)), response)
739
SuccessfulSmartServerResponse(('',)), response)
1125
742
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
1145
762
def test_lock_write_on_unlocked_branch(self):
1146
763
backing = self.get_transport()
1147
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
764
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1148
765
branch = self.make_branch('.', format='knit')
1149
766
repository = branch.repository
1150
767
response = request.execute('')
1151
768
branch_nonce = branch.control_files._lock.peek().get('nonce')
1152
769
repository_nonce = repository.control_files._lock.peek().get('nonce')
1153
self.assertEqual(smart_req.SmartServerResponse(
1154
('ok', branch_nonce, repository_nonce)),
771
SmartServerResponse(('ok', branch_nonce, repository_nonce)),
1156
773
# The branch (and associated repository) is now locked. Verify that
1157
774
# with a new branch object.
1158
775
new_branch = repository.bzrdir.open_branch()
1159
776
self.assertRaises(errors.LockContention, new_branch.lock_write)
1161
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1162
response = request.execute('', branch_nonce, repository_nonce)
1164
778
def test_lock_write_on_locked_branch(self):
1165
779
backing = self.get_transport()
1166
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
780
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1167
781
branch = self.make_branch('.')
1168
branch_token = branch.lock_write()
1169
783
branch.leave_lock_in_place()
1171
785
response = request.execute('')
1172
786
self.assertEqual(
1173
smart_req.SmartServerResponse(('LockContention',)), response)
1175
branch.lock_write(branch_token)
1176
branch.dont_leave_lock_in_place()
787
SmartServerResponse(('LockContention',)), response)
1179
789
def test_lock_write_with_tokens_on_locked_branch(self):
1180
790
backing = self.get_transport()
1181
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
791
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1182
792
branch = self.make_branch('.', format='knit')
1183
793
branch_token = branch.lock_write()
1184
794
repo_token = branch.repository.lock_write()
1212
814
response = request.execute('',
1213
815
branch_token+'xxx', repo_token)
1214
816
self.assertEqual(
1215
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1217
branch.repository.lock_write(repo_token)
1218
branch.repository.dont_leave_lock_in_place()
1219
branch.repository.unlock()
1220
branch.lock_write(branch_token)
1221
branch.dont_leave_lock_in_place()
817
SmartServerResponse(('TokenMismatch',)), response)
1224
819
def test_lock_write_on_locked_repo(self):
1225
820
backing = self.get_transport()
1226
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
821
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1227
822
branch = self.make_branch('.', format='knit')
1228
repo = branch.repository
1229
repo_token = repo.lock_write()
1230
repo.leave_lock_in_place()
823
branch.repository.lock_write()
824
branch.repository.leave_lock_in_place()
825
branch.repository.unlock()
1232
826
response = request.execute('')
1233
827
self.assertEqual(
1234
smart_req.SmartServerResponse(('LockContention',)), response)
1236
repo.lock_write(repo_token)
1237
repo.dont_leave_lock_in_place()
828
SmartServerResponse(('LockContention',)), response)
1240
830
def test_lock_write_on_readonly_transport(self):
1241
831
backing = self.get_readonly_transport()
1242
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
832
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1243
833
branch = self.make_branch('.')
1244
834
root = self.get_transport().clone('/')
1245
835
path = urlutils.relative_url(root.base, self.get_transport().base)
1327
913
def test_trivial_bzipped(self):
1328
914
# This tests that the wire encoding is actually bzipped
1329
915
backing = self.get_transport()
1330
request = smart_repo.SmartServerRepositoryGetParentMap(backing)
916
request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1331
917
tree = self.make_branch_and_memory_tree('.')
1333
919
self.assertEqual(None,
1334
920
request.execute('', 'missing-id'))
1335
# Note that it returns a body that is bzipped.
1337
smart_req.SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1338
request.do_body('\n\n0\n'))
1340
def test_trivial_include_missing(self):
1341
backing = self.get_transport()
1342
request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1343
tree = self.make_branch_and_memory_tree('.')
1345
self.assertEqual(None,
1346
request.execute('', 'missing-id', 'include-missing:'))
1348
smart_req.SuccessfulSmartServerResponse(('ok', ),
1349
bz2.compress('missing:missing-id')),
1350
request.do_body('\n\n0\n'))
1353
class TestSmartServerRepositoryGetRevisionGraph(
1354
tests.TestCaseWithMemoryTransport):
921
# Note that it returns a body (of '' bzipped).
923
SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
924
request.do_body('\n\n0\n'))
927
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
1356
929
def test_none_argument(self):
1357
930
backing = self.get_transport()
1358
request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
931
request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1359
932
tree = self.make_branch_and_memory_tree('.')
1360
933
tree.lock_write()
1398
971
# Note that it still returns body (of zero bytes).
1399
self.assertEqual(smart_req.SmartServerResponse(
1400
('nosuchrevision', 'missingrevision', ), ''),
1401
request.execute('', 'missingrevision'))
1404
class TestSmartServerRepositoryGetRevIdForRevno(
1405
tests.TestCaseWithMemoryTransport):
1407
def test_revno_found(self):
1408
backing = self.get_transport()
1409
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1410
tree = self.make_branch_and_memory_tree('.')
1413
rev1_id_utf8 = u'\xc8'.encode('utf-8')
1414
rev2_id_utf8 = u'\xc9'.encode('utf-8')
1415
tree.commit('1st commit', rev_id=rev1_id_utf8)
1416
tree.commit('2nd commit', rev_id=rev2_id_utf8)
1419
self.assertEqual(smart_req.SmartServerResponse(('ok', rev1_id_utf8)),
1420
request.execute('', 1, (2, rev2_id_utf8)))
1422
def test_known_revid_missing(self):
1423
backing = self.get_transport()
1424
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1425
repo = self.make_repository('.')
1427
smart_req.FailedSmartServerResponse(('nosuchrevision', 'ghost')),
1428
request.execute('', 1, (2, 'ghost')))
1430
def test_history_incomplete(self):
1431
backing = self.get_transport()
1432
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1433
parent = self.make_branch_and_memory_tree('parent', format='1.9')
1435
parent.add([''], ['TREE_ROOT'])
1436
r1 = parent.commit(message='first commit')
1437
r2 = parent.commit(message='second commit')
1439
local = self.make_branch_and_memory_tree('local', format='1.9')
1440
local.branch.pull(parent.branch)
1441
local.set_parent_ids([r2])
1442
r3 = local.commit(message='local commit')
1443
local.branch.create_clone_on_transport(
1444
self.get_transport('stacked'), stacked_on=self.get_url('parent'))
1446
smart_req.SmartServerResponse(('history-incomplete', 2, r2)),
1447
request.execute('stacked', 1, (3, r3)))
973
SmartServerResponse(('nosuchrevision', 'missingrevision', ), ''),
974
request.execute('', 'missingrevision'))
1450
977
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1575
1102
def test_is_shared(self):
1576
1103
"""For a shared repository, ('yes', ) is returned."""
1577
1104
backing = self.get_transport()
1578
request = smart_repo.SmartServerRepositoryIsShared(backing)
1105
request = smart.repository.SmartServerRepositoryIsShared(backing)
1579
1106
self.make_repository('.', shared=True)
1580
self.assertEqual(smart_req.SmartServerResponse(('yes', )),
1107
self.assertEqual(SmartServerResponse(('yes', )),
1581
1108
request.execute('', ))
1583
1110
def test_is_not_shared(self):
1584
1111
"""For a shared repository, ('no', ) is returned."""
1585
1112
backing = self.get_transport()
1586
request = smart_repo.SmartServerRepositoryIsShared(backing)
1113
request = smart.repository.SmartServerRepositoryIsShared(backing)
1587
1114
self.make_repository('.', shared=False)
1588
self.assertEqual(smart_req.SmartServerResponse(('no', )),
1115
self.assertEqual(SmartServerResponse(('no', )),
1589
1116
request.execute('', ))
1592
1119
class TestSmartServerRepositoryLockWrite(tests.TestCaseWithMemoryTransport):
1122
tests.TestCaseWithMemoryTransport.setUp(self)
1594
1124
def test_lock_write_on_unlocked_repo(self):
1595
1125
backing = self.get_transport()
1596
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1126
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1597
1127
repository = self.make_repository('.', format='knit')
1598
1128
response = request.execute('')
1599
1129
nonce = repository.control_files._lock.peek().get('nonce')
1600
self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
1130
self.assertEqual(SmartServerResponse(('ok', nonce)), response)
1601
1131
# The repository is now locked. Verify that with a new repository
1603
1133
new_repo = repository.bzrdir.open_repository()
1604
1134
self.assertRaises(errors.LockContention, new_repo.lock_write)
1606
request = smart_repo.SmartServerRepositoryUnlock(backing)
1607
response = request.execute('', nonce)
1609
1136
def test_lock_write_on_locked_repo(self):
1610
1137
backing = self.get_transport()
1611
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1138
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1612
1139
repository = self.make_repository('.', format='knit')
1613
repo_token = repository.lock_write()
1140
repository.lock_write()
1614
1141
repository.leave_lock_in_place()
1615
1142
repository.unlock()
1616
1143
response = request.execute('')
1617
1144
self.assertEqual(
1618
smart_req.SmartServerResponse(('LockContention',)), response)
1620
repository.lock_write(repo_token)
1621
repository.dont_leave_lock_in_place()
1145
SmartServerResponse(('LockContention',)), response)
1624
1147
def test_lock_write_on_readonly_transport(self):
1625
1148
backing = self.get_readonly_transport()
1626
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1149
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1627
1150
repository = self.make_repository('.', format='knit')
1628
1151
response = request.execute('')
1629
1152
self.assertFalse(response.is_successful())
1630
1153
self.assertEqual('LockFailed', response.args[0])
1633
class TestInsertStreamBase(tests.TestCaseWithMemoryTransport):
1635
def make_empty_byte_stream(self, repo):
1636
byte_stream = smart_repo._stream_to_byte_stream([], repo._format)
1637
return ''.join(byte_stream)
1640
class TestSmartServerRepositoryInsertStream(TestInsertStreamBase):
1642
def test_insert_stream_empty(self):
1643
backing = self.get_transport()
1644
request = smart_repo.SmartServerRepositoryInsertStream(backing)
1645
repository = self.make_repository('.')
1646
response = request.execute('', '')
1647
self.assertEqual(None, response)
1648
response = request.do_chunk(self.make_empty_byte_stream(repository))
1649
self.assertEqual(None, response)
1650
response = request.do_end()
1651
self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1654
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
1656
def test_insert_stream_empty(self):
1657
backing = self.get_transport()
1658
request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1660
repository = self.make_repository('.', format='knit')
1661
lock_token = repository.lock_write()
1662
response = request.execute('', '', lock_token)
1663
self.assertEqual(None, response)
1664
response = request.do_chunk(self.make_empty_byte_stream(repository))
1665
self.assertEqual(None, response)
1666
response = request.do_end()
1667
self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1670
def test_insert_stream_with_wrong_lock_token(self):
1671
backing = self.get_transport()
1672
request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1674
repository = self.make_repository('.', format='knit')
1675
lock_token = repository.lock_write()
1677
errors.TokenMismatch, request.execute, '', '', 'wrong-token')
1681
1156
class TestSmartServerRepositoryUnlock(tests.TestCaseWithMemoryTransport):
1683
1158
def setUp(self):
1702
1177
def test_unlock_on_unlocked_repo(self):
1703
1178
backing = self.get_transport()
1704
request = smart_repo.SmartServerRepositoryUnlock(backing)
1179
request = smart.repository.SmartServerRepositoryUnlock(backing)
1705
1180
repository = self.make_repository('.', format='knit')
1706
1181
response = request.execute('', 'some token')
1707
1182
self.assertEqual(
1708
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1183
SmartServerResponse(('TokenMismatch',)), response)
1711
1186
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1713
1188
def test_is_readonly_no(self):
1714
1189
backing = self.get_transport()
1715
request = smart_req.SmartServerIsReadonly(backing)
1190
request = smart.request.SmartServerIsReadonly(backing)
1716
1191
response = request.execute()
1717
1192
self.assertEqual(
1718
smart_req.SmartServerResponse(('no',)), response)
1193
SmartServerResponse(('no',)), response)
1720
1195
def test_is_readonly_yes(self):
1721
1196
backing = self.get_readonly_transport()
1722
request = smart_req.SmartServerIsReadonly(backing)
1197
request = smart.request.SmartServerIsReadonly(backing)
1723
1198
response = request.execute()
1724
1199
self.assertEqual(
1725
smart_req.SmartServerResponse(('yes',)), response)
1728
class TestSmartServerRepositorySetMakeWorkingTrees(
1729
tests.TestCaseWithMemoryTransport):
1200
SmartServerResponse(('yes',)), response)
1203
class TestSmartServerRepositorySetMakeWorkingTrees(tests.TestCaseWithMemoryTransport):
1731
1205
def test_set_false(self):
1732
1206
backing = self.get_transport()
1733
1207
repo = self.make_repository('.', shared=True)
1734
1208
repo.set_make_working_trees(True)
1735
request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
1209
request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1736
1210
request = request_class(backing)
1737
self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
1211
self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1738
1212
request.execute('', 'False'))
1739
1213
repo = repo.bzrdir.open_repository()
1740
1214
self.assertFalse(repo.make_working_trees())
1822
1279
"""All registered request_handlers can be found."""
1823
1280
# If there's a typo in a register_lazy call, this loop will fail with
1824
1281
# an AttributeError.
1825
for key, item in smart_req.request_handlers.iteritems():
1282
for key, item in smart.request.request_handlers.iteritems():
1828
def assertHandlerEqual(self, verb, handler):
1829
self.assertEqual(smart_req.request_handlers.get(verb), handler)
1831
1285
def test_registered_methods(self):
1832
1286
"""Test that known methods are registered to the correct object."""
1833
self.assertHandlerEqual('Branch.get_config_file',
1834
smart_branch.SmartServerBranchGetConfigFile)
1835
self.assertHandlerEqual('Branch.get_parent',
1836
smart_branch.SmartServerBranchGetParent)
1837
self.assertHandlerEqual('Branch.get_tags_bytes',
1838
smart_branch.SmartServerBranchGetTagsBytes)
1839
self.assertHandlerEqual('Branch.lock_write',
1840
smart_branch.SmartServerBranchRequestLockWrite)
1841
self.assertHandlerEqual('Branch.last_revision_info',
1842
smart_branch.SmartServerBranchRequestLastRevisionInfo)
1843
self.assertHandlerEqual('Branch.revision_history',
1844
smart_branch.SmartServerRequestRevisionHistory)
1845
self.assertHandlerEqual('Branch.set_config_option',
1846
smart_branch.SmartServerBranchRequestSetConfigOption)
1847
self.assertHandlerEqual('Branch.set_last_revision',
1848
smart_branch.SmartServerBranchRequestSetLastRevision)
1849
self.assertHandlerEqual('Branch.set_last_revision_info',
1850
smart_branch.SmartServerBranchRequestSetLastRevisionInfo)
1851
self.assertHandlerEqual('Branch.set_last_revision_ex',
1852
smart_branch.SmartServerBranchRequestSetLastRevisionEx)
1853
self.assertHandlerEqual('Branch.set_parent_location',
1854
smart_branch.SmartServerBranchRequestSetParentLocation)
1855
self.assertHandlerEqual('Branch.unlock',
1856
smart_branch.SmartServerBranchRequestUnlock)
1857
self.assertHandlerEqual('BzrDir.find_repository',
1858
smart_dir.SmartServerRequestFindRepositoryV1)
1859
self.assertHandlerEqual('BzrDir.find_repositoryV2',
1860
smart_dir.SmartServerRequestFindRepositoryV2)
1861
self.assertHandlerEqual('BzrDirFormat.initialize',
1862
smart_dir.SmartServerRequestInitializeBzrDir)
1863
self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
1864
smart_dir.SmartServerRequestBzrDirInitializeEx)
1865
self.assertHandlerEqual('BzrDir.cloning_metadir',
1866
smart_dir.SmartServerBzrDirRequestCloningMetaDir)
1867
self.assertHandlerEqual('BzrDir.get_config_file',
1868
smart_dir.SmartServerBzrDirRequestConfigFile)
1869
self.assertHandlerEqual('BzrDir.open_branch',
1870
smart_dir.SmartServerRequestOpenBranch)
1871
self.assertHandlerEqual('BzrDir.open_branchV2',
1872
smart_dir.SmartServerRequestOpenBranchV2)
1873
self.assertHandlerEqual('BzrDir.open_branchV3',
1874
smart_dir.SmartServerRequestOpenBranchV3)
1875
self.assertHandlerEqual('PackRepository.autopack',
1876
smart_packrepo.SmartServerPackRepositoryAutopack)
1877
self.assertHandlerEqual('Repository.gather_stats',
1878
smart_repo.SmartServerRepositoryGatherStats)
1879
self.assertHandlerEqual('Repository.get_parent_map',
1880
smart_repo.SmartServerRepositoryGetParentMap)
1881
self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1882
smart_repo.SmartServerRepositoryGetRevIdForRevno)
1883
self.assertHandlerEqual('Repository.get_revision_graph',
1884
smart_repo.SmartServerRepositoryGetRevisionGraph)
1885
self.assertHandlerEqual('Repository.get_stream',
1886
smart_repo.SmartServerRepositoryGetStream)
1887
self.assertHandlerEqual('Repository.has_revision',
1888
smart_repo.SmartServerRequestHasRevision)
1889
self.assertHandlerEqual('Repository.insert_stream',
1890
smart_repo.SmartServerRepositoryInsertStream)
1891
self.assertHandlerEqual('Repository.insert_stream_locked',
1892
smart_repo.SmartServerRepositoryInsertStreamLocked)
1893
self.assertHandlerEqual('Repository.is_shared',
1894
smart_repo.SmartServerRepositoryIsShared)
1895
self.assertHandlerEqual('Repository.lock_write',
1896
smart_repo.SmartServerRepositoryLockWrite)
1897
self.assertHandlerEqual('Repository.tarball',
1898
smart_repo.SmartServerRepositoryTarball)
1899
self.assertHandlerEqual('Repository.unlock',
1900
smart_repo.SmartServerRepositoryUnlock)
1901
self.assertHandlerEqual('Transport.is_readonly',
1902
smart_req.SmartServerIsReadonly)
1288
smart.request.request_handlers.get('Branch.get_config_file'),
1289
smart.branch.SmartServerBranchGetConfigFile)
1291
smart.request.request_handlers.get('Branch.get_parent'),
1292
smart.branch.SmartServerBranchGetParent)
1294
smart.request.request_handlers.get('Branch.get_tags_bytes'),
1295
smart.branch.SmartServerBranchGetTagsBytes)
1297
smart.request.request_handlers.get('Branch.lock_write'),
1298
smart.branch.SmartServerBranchRequestLockWrite)
1300
smart.request.request_handlers.get('Branch.last_revision_info'),
1301
smart.branch.SmartServerBranchRequestLastRevisionInfo)
1303
smart.request.request_handlers.get('Branch.revision_history'),
1304
smart.branch.SmartServerRequestRevisionHistory)
1306
smart.request.request_handlers.get('Branch.set_last_revision'),
1307
smart.branch.SmartServerBranchRequestSetLastRevision)
1309
smart.request.request_handlers.get('Branch.set_last_revision_info'),
1310
smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
1312
smart.request.request_handlers.get('Branch.unlock'),
1313
smart.branch.SmartServerBranchRequestUnlock)
1315
smart.request.request_handlers.get('BzrDir.find_repository'),
1316
smart.bzrdir.SmartServerRequestFindRepositoryV1)
1318
smart.request.request_handlers.get('BzrDir.find_repositoryV2'),
1319
smart.bzrdir.SmartServerRequestFindRepositoryV2)
1321
smart.request.request_handlers.get('BzrDirFormat.initialize'),
1322
smart.bzrdir.SmartServerRequestInitializeBzrDir)
1324
smart.request.request_handlers.get('BzrDir.cloning_metadir'),
1325
smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
1327
smart.request.request_handlers.get('BzrDir.open_branch'),
1328
smart.bzrdir.SmartServerRequestOpenBranch)
1330
smart.request.request_handlers.get('BzrDir.open_branchV2'),
1331
smart.bzrdir.SmartServerRequestOpenBranchV2)
1333
smart.request.request_handlers.get('PackRepository.autopack'),
1334
smart.packrepository.SmartServerPackRepositoryAutopack)
1336
smart.request.request_handlers.get('Repository.gather_stats'),
1337
smart.repository.SmartServerRepositoryGatherStats)
1339
smart.request.request_handlers.get('Repository.get_parent_map'),
1340
smart.repository.SmartServerRepositoryGetParentMap)
1342
smart.request.request_handlers.get(
1343
'Repository.get_revision_graph'),
1344
smart.repository.SmartServerRepositoryGetRevisionGraph)
1346
smart.request.request_handlers.get('Repository.has_revision'),
1347
smart.repository.SmartServerRequestHasRevision)
1349
smart.request.request_handlers.get('Repository.is_shared'),
1350
smart.repository.SmartServerRepositoryIsShared)
1352
smart.request.request_handlers.get('Repository.lock_write'),
1353
smart.repository.SmartServerRepositoryLockWrite)
1355
smart.request.request_handlers.get('Repository.get_stream'),
1356
smart.repository.SmartServerRepositoryGetStream)
1358
smart.request.request_handlers.get('Repository.tarball'),
1359
smart.repository.SmartServerRepositoryTarball)
1361
smart.request.request_handlers.get('Repository.unlock'),
1362
smart.repository.SmartServerRepositoryUnlock)
1364
smart.request.request_handlers.get('Transport.is_readonly'),
1365
smart.request.SmartServerIsReadonly)
added
removed
bzrlib/tests/test_smart.py
