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 (
53
from bzrlib.transport import chroot, get_transport
54
from bzrlib.util import bencode
58
57
def load_tests(standard_tests, module, loader):
59
58
"""Multiply tests version and protocol consistency."""
60
59
# FindRepository tests.
60
bzrdir_mod = bzrlib.smart.bzrdir
62
62
("find_repository", {
63
"_request_class": smart_dir.SmartServerRequestFindRepositoryV1}),
63
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV1}),
64
64
("find_repositoryV2", {
65
"_request_class": smart_dir.SmartServerRequestFindRepositoryV2}),
65
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV2}),
66
66
("find_repositoryV3", {
67
"_request_class": smart_dir.SmartServerRequestFindRepositoryV3}),
67
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV3}),
69
to_adapt, result = tests.split_suite_by_re(standard_tests,
69
to_adapt, result = split_suite_by_re(standard_tests,
70
70
"TestSmartServerRequestFindRepository")
71
v2_only, v1_and_2 = tests.split_suite_by_re(to_adapt,
71
v2_only, v1_and_2 = split_suite_by_re(to_adapt,
73
73
tests.multiply_tests(v1_and_2, scenarios, result)
74
74
# The first scenario is only applicable to v1 protocols, it is deleted
106
106
self.transport_server = self.make_transport_server
108
108
def make_transport_server(self):
109
return test_server.SmartTCPServer_for_testing('-' + self.id())
109
return smart.server.SmartTCPServer_for_testing('-' + self.id())
111
111
def get_smart_medium(self):
112
112
"""Get a smart medium to use in tests."""
113
113
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
116
class TestSmartServerResponse(tests.TestCase):
137
118
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', )))
119
self.assertEqual(SmartServerResponse(('ok', )),
120
SmartServerResponse(('ok', )))
121
self.assertEqual(SmartServerResponse(('ok', ), 'body'),
122
SmartServerResponse(('ok', ), 'body'))
123
self.assertNotEqual(SmartServerResponse(('ok', )),
124
SmartServerResponse(('notok', )))
125
self.assertNotEqual(SmartServerResponse(('ok', ), 'body'),
126
SmartServerResponse(('ok', )))
146
127
self.assertNotEqual(None,
147
smart_req.SmartServerResponse(('ok', )))
128
SmartServerResponse(('ok', )))
149
130
def test__str__(self):
150
131
"""SmartServerResponses can be stringified."""
151
132
self.assertEqual(
152
133
"<SuccessfulSmartServerResponse args=('args',) body='body'>",
153
str(smart_req.SuccessfulSmartServerResponse(('args',), 'body')))
134
str(SuccessfulSmartServerResponse(('args',), 'body')))
154
135
self.assertEqual(
155
136
"<FailedSmartServerResponse args=('args',) body='body'>",
156
str(smart_req.FailedSmartServerResponse(('args',), 'body')))
137
str(FailedSmartServerResponse(('args',), 'body')))
159
140
class TestSmartServerRequest(tests.TestCaseWithMemoryTransport):
161
142
def test_translate_client_path(self):
162
143
transport = self.get_transport()
163
request = smart_req.SmartServerRequest(transport, 'foo/')
144
request = SmartServerRequest(transport, 'foo/')
164
145
self.assertEqual('./', request.translate_client_path('foo/'))
165
146
self.assertRaises(
166
147
errors.InvalidURLJoin, request.translate_client_path, 'foo/..')
282
if repo._format.supports_external_lookups:
286
if (smart_dir.SmartServerRequestFindRepositoryV3 ==
250
if (smart.bzrdir.SmartServerRequestFindRepositoryV3 ==
287
251
self._request_class):
288
return smart_req.SuccessfulSmartServerResponse(
289
('ok', '', rich_root, subtrees, external,
252
return SuccessfulSmartServerResponse(
253
('ok', '', rich_root, subtrees, 'no',
290
254
repo._format.network_name()))
291
elif (smart_dir.SmartServerRequestFindRepositoryV2 ==
255
elif (smart.bzrdir.SmartServerRequestFindRepositoryV2 ==
292
256
self._request_class):
293
257
# All tests so far are on formats, and for non-external
295
return smart_req.SuccessfulSmartServerResponse(
296
('ok', '', rich_root, subtrees, external))
259
return SuccessfulSmartServerResponse(
260
('ok', '', rich_root, subtrees, 'no'))
298
return smart_req.SuccessfulSmartServerResponse(
299
('ok', '', rich_root, subtrees))
262
return SuccessfulSmartServerResponse(('ok', '', rich_root, subtrees))
301
264
def test_shared_repository(self):
302
265
"""When there is a shared repository, we get 'ok', 'relpath-to-repo'."""
330
290
"""Test for the supports_external_lookups attribute."""
331
291
backing = self.get_transport()
332
292
request = self._request_class(backing)
333
result = self._make_repository_and_result(
334
format='dirstate-with-subtree')
293
result = self._make_repository_and_result(format='dirstate-with-subtree')
335
294
# check the test will be valid
336
295
self.assertEqual('no', result.args[4])
337
296
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
299
class TestSmartServerRequestInitializeBzrDir(tests.TestCaseWithMemoryTransport):
365
301
def test_empty_dir(self):
366
302
"""Initializing an empty dir should succeed and do it."""
367
303
backing = self.get_transport()
368
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
369
self.assertEqual(smart_req.SmartServerResponse(('ok', )),
304
request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
305
self.assertEqual(SmartServerResponse(('ok', )),
370
306
request.execute(''))
371
307
made_dir = bzrdir.BzrDir.open_from_transport(backing)
372
308
# no branch, tree or repository is expected with the current
378
314
def test_missing_dir(self):
379
315
"""Initializing a missing directory should fail like the bzrdir api."""
380
316
backing = self.get_transport()
381
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
317
request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
382
318
self.assertRaises(errors.NoSuchFile,
383
319
request.execute, 'subdir')
385
321
def test_initialized_dir(self):
386
322
"""Initializing an extant bzrdir should fail like the bzrdir api."""
387
323
backing = self.get_transport()
388
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
324
request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
389
325
self.make_bzrdir('subdir')
390
326
self.assertRaises(errors.FileExists,
391
327
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
330
class TestSmartServerRequestOpenBranch(TestCaseWithChrootedTransport):
505
332
def test_no_branch(self):
506
333
"""When there is no branch, ('nobranch', ) is returned."""
507
334
backing = self.get_transport()
508
request = smart_dir.SmartServerRequestOpenBranch(backing)
335
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
509
336
self.make_bzrdir('.')
510
self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
337
self.assertEqual(SmartServerResponse(('nobranch', )),
511
338
request.execute(''))
513
340
def test_branch(self):
514
341
"""When there is a branch, 'ok' is returned."""
515
342
backing = self.get_transport()
516
request = smart_dir.SmartServerRequestOpenBranch(backing)
343
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
517
344
self.make_branch('.')
518
self.assertEqual(smart_req.SmartServerResponse(('ok', '')),
345
self.assertEqual(SmartServerResponse(('ok', '')),
519
346
request.execute(''))
521
348
def test_branch_reference(self):
522
349
"""When there is a branch reference, the reference URL is returned."""
523
self.vfs_transport_factory = test_server.LocalURLServer
524
350
backing = self.get_transport()
525
request = smart_dir.SmartServerRequestOpenBranch(backing)
351
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
526
352
branch = self.make_branch('branch')
527
353
checkout = branch.create_checkout('reference',lightweight=True)
528
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
354
reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
530
355
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
531
self.assertEqual(smart_req.SmartServerResponse(('ok', reference_url)),
356
self.assertEqual(SmartServerResponse(('ok', reference_url)),
532
357
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
360
class TestSmartServerRequestOpenBranchV2(TestCaseWithChrootedTransport):
546
363
"""When there is no branch, ('nobranch', ) is returned."""
547
364
backing = self.get_transport()
548
365
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')),
366
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
367
self.assertEqual(SmartServerResponse(('nobranch', )),
370
def test_branch(self):
371
"""When there is a branch, 'ok' is returned."""
372
backing = self.get_transport()
373
expected = self.make_branch('.')._format.network_name()
374
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
375
self.assertEqual(SuccessfulSmartServerResponse(('branch', expected)),
378
def test_branch_reference(self):
379
"""When there is a branch reference, the reference URL is returned."""
380
backing = self.get_transport()
381
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
382
branch = self.make_branch('branch')
383
checkout = branch.create_checkout('reference',lightweight=True)
384
reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
385
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
386
self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
387
request.execute('reference'))
389
def test_stacked_branch(self):
390
"""Opening a stacked branch does not open the stacked-on branch."""
391
trunk = self.make_branch('trunk')
392
feature = self.make_branch('feature', format='1.9')
393
feature.set_stacked_on_url(trunk.base)
395
Branch.hooks.install_named_hook('open', opened_branches.append, None)
396
backing = self.get_transport()
397
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
400
response = request.execute('feature')
402
request.teardown_jail()
403
expected_format = feature._format.network_name()
405
SuccessfulSmartServerResponse(('branch', expected_format)),
407
self.assertLength(1, opened_branches)
670
410
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
705
445
def test_branch_reference(self):
706
446
"""When there is a branch reference, NotBranchError is raised."""
707
447
backing = self.get_transport()
708
request = smart_branch.SmartServerBranchRequest(backing)
448
request = smart.branch.SmartServerBranchRequest(backing)
709
449
branch = self.make_branch('branch')
710
450
checkout = branch.create_checkout('reference',lightweight=True)
711
451
self.assertRaises(errors.NotBranchError,
712
452
request.execute, 'checkout')
715
class TestSmartServerBranchRequestLastRevisionInfo(
716
tests.TestCaseWithMemoryTransport):
455
class TestSmartServerBranchRequestLastRevisionInfo(tests.TestCaseWithMemoryTransport):
718
457
def test_empty(self):
719
458
"""For an empty branch, the result is ('ok', '0', 'null:')."""
720
459
backing = self.get_transport()
721
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
460
request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
722
461
self.make_branch('.')
723
self.assertEqual(smart_req.SmartServerResponse(('ok', '0', 'null:')),
462
self.assertEqual(SmartServerResponse(('ok', '0', 'null:')),
724
463
request.execute(''))
726
465
def test_not_empty(self):
727
466
"""For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
728
467
backing = self.get_transport()
729
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
468
request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
730
469
tree = self.make_branch_and_memory_tree('.')
731
470
tree.lock_write()
778
516
def test_value_name(self):
779
517
branch = self.make_branch('.')
780
request = smart_branch.SmartServerBranchRequestSetConfigOption(
518
request = smart.branch.SmartServerBranchRequestSetConfigOption(
781
519
branch.bzrdir.root_transport)
782
520
branch_token, repo_token = self.get_lock_tokens(branch)
783
521
config = branch._get_config()
784
522
result = request.execute('', branch_token, repo_token, 'bar', 'foo',
786
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
524
self.assertEqual(SuccessfulSmartServerResponse(()), result)
787
525
self.assertEqual('bar', config.get_option('foo'))
791
527
def test_value_name_section(self):
792
528
branch = self.make_branch('.')
793
request = smart_branch.SmartServerBranchRequestSetConfigOption(
529
request = smart.branch.SmartServerBranchRequestSetConfigOption(
794
530
branch.bzrdir.root_transport)
795
531
branch_token, repo_token = self.get_lock_tokens(branch)
796
532
config = branch._get_config()
797
533
result = request.execute('', branch_token, repo_token, 'bar', 'foo',
799
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
535
self.assertEqual(SuccessfulSmartServerResponse(()), result)
800
536
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
539
class SetLastRevisionTestBase(TestLockedBranch):
1059
755
def test_get_parent_none(self):
1060
756
base_branch = self.make_branch('base')
1061
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
757
request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1062
758
response = request.execute('base')
1063
759
self.assertEquals(
1064
smart_req.SuccessfulSmartServerResponse(('',)), response)
760
SuccessfulSmartServerResponse(('',)), response)
1066
762
def test_get_parent_something(self):
1067
763
base_branch = self.make_branch('base')
1068
764
base_branch.set_parent(self.get_url('foo'))
1069
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
765
request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1070
766
response = request.execute('base')
1071
767
self.assertEquals(
1072
smart_req.SuccessfulSmartServerResponse(("../foo",)),
768
SuccessfulSmartServerResponse(("../foo",)),
1076
class TestSmartServerBranchRequestSetParent(TestLockedBranch):
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, repo_token = self.get_lock_tokens(branch)
1087
response = request.execute('base', branch_token, repo_token, '')
1090
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1091
self.assertEqual(None, branch.get_parent())
1093
def test_set_parent_something(self):
1094
branch = self.make_branch('base', format="1.9")
1095
request = smart_branch.SmartServerBranchRequestSetParentLocation(
1096
self.get_transport())
1097
branch_token, repo_token = self.get_lock_tokens(branch)
1099
response = request.execute('base', branch_token, repo_token,
1103
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1104
self.assertEqual('http://bar/', branch.get_parent())
1107
class TestSmartServerBranchRequestGetTagsBytes(
1108
tests.TestCaseWithMemoryTransport):
1109
# Only called when the branch format and tags match [yay factory
1110
# methods] so only need to test straight forward cases.
772
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
773
# Only called when the branch format and tags match [yay factory
774
# methods] so only need to test straight forward cases.
1112
776
def test_get_bytes(self):
1113
777
base_branch = self.make_branch('base')
1114
request = smart_branch.SmartServerBranchGetTagsBytes(
778
request = smart.branch.SmartServerBranchGetTagsBytes(
1115
779
self.get_transport())
1116
780
response = request.execute('base')
1117
781
self.assertEquals(
1118
smart_req.SuccessfulSmartServerResponse(('',)), response)
782
SuccessfulSmartServerResponse(('',)), response)
1121
785
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
1125
789
stacked_branch = self.make_branch('stacked', format='1.6')
1126
790
# typically should be relative
1127
791
stacked_branch.set_stacked_on_url('../base')
1128
request = smart_branch.SmartServerBranchRequestGetStackedOnURL(
792
request = smart.branch.SmartServerBranchRequestGetStackedOnURL(
1129
793
self.get_transport())
1130
794
response = request.execute('stacked')
1131
795
self.assertEquals(
1132
smart_req.SmartServerResponse(('ok', '../base')),
796
SmartServerResponse(('ok', '../base')),
1136
class TestSmartServerBranchRequestLockWrite(TestLockedBranch):
800
class TestSmartServerBranchRequestLockWrite(tests.TestCaseWithMemoryTransport):
1138
802
def setUp(self):
1139
803
tests.TestCaseWithMemoryTransport.setUp(self)
1141
805
def test_lock_write_on_unlocked_branch(self):
1142
806
backing = self.get_transport()
1143
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
807
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1144
808
branch = self.make_branch('.', format='knit')
1145
809
repository = branch.repository
1146
810
response = request.execute('')
1147
811
branch_nonce = branch.control_files._lock.peek().get('nonce')
1148
812
repository_nonce = repository.control_files._lock.peek().get('nonce')
1149
self.assertEqual(smart_req.SmartServerResponse(
1150
('ok', branch_nonce, repository_nonce)),
814
SmartServerResponse(('ok', branch_nonce, repository_nonce)),
1152
816
# The branch (and associated repository) is now locked. Verify that
1153
817
# with a new branch object.
1154
818
new_branch = repository.bzrdir.open_branch()
1155
819
self.assertRaises(errors.LockContention, new_branch.lock_write)
1157
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1158
response = request.execute('', branch_nonce, repository_nonce)
1160
821
def test_lock_write_on_locked_branch(self):
1161
822
backing = self.get_transport()
1162
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
823
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1163
824
branch = self.make_branch('.')
1164
branch_token = branch.lock_write().branch_token
1165
826
branch.leave_lock_in_place()
1167
828
response = request.execute('')
1168
829
self.assertEqual(
1169
smart_req.SmartServerResponse(('LockContention',)), response)
1171
branch.lock_write(branch_token)
1172
branch.dont_leave_lock_in_place()
830
SmartServerResponse(('LockContention',)), response)
1175
832
def test_lock_write_with_tokens_on_locked_branch(self):
1176
833
backing = self.get_transport()
1177
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
834
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1178
835
branch = self.make_branch('.', format='knit')
1179
branch_token, repo_token = self.get_lock_tokens(branch)
836
branch_token = branch.lock_write()
837
repo_token = branch.repository.lock_write()
838
branch.repository.unlock()
1180
839
branch.leave_lock_in_place()
1181
840
branch.repository.leave_lock_in_place()
1183
842
response = request.execute('',
1184
843
branch_token, repo_token)
1185
844
self.assertEqual(
1186
smart_req.SmartServerResponse(('ok', branch_token, repo_token)),
1189
branch.repository.lock_write(repo_token)
1190
branch.repository.dont_leave_lock_in_place()
1191
branch.repository.unlock()
1192
branch.lock_write(branch_token)
1193
branch.dont_leave_lock_in_place()
845
SmartServerResponse(('ok', branch_token, repo_token)), response)
1196
847
def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
1197
848
backing = self.get_transport()
1198
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
849
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1199
850
branch = self.make_branch('.', format='knit')
1200
branch_token, repo_token = self.get_lock_tokens(branch)
851
branch_token = branch.lock_write()
852
repo_token = branch.repository.lock_write()
853
branch.repository.unlock()
1201
854
branch.leave_lock_in_place()
1202
855
branch.repository.leave_lock_in_place()
1204
857
response = request.execute('',
1205
858
branch_token+'xxx', repo_token)
1206
859
self.assertEqual(
1207
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1209
branch.repository.lock_write(repo_token)
1210
branch.repository.dont_leave_lock_in_place()
1211
branch.repository.unlock()
1212
branch.lock_write(branch_token)
1213
branch.dont_leave_lock_in_place()
860
SmartServerResponse(('TokenMismatch',)), response)
1216
862
def test_lock_write_on_locked_repo(self):
1217
863
backing = self.get_transport()
1218
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
864
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1219
865
branch = self.make_branch('.', format='knit')
1220
repo = branch.repository
1221
repo_token = repo.lock_write().repository_token
1222
repo.leave_lock_in_place()
866
branch.repository.lock_write()
867
branch.repository.leave_lock_in_place()
868
branch.repository.unlock()
1224
869
response = request.execute('')
1225
870
self.assertEqual(
1226
smart_req.SmartServerResponse(('LockContention',)), response)
1228
repo.lock_write(repo_token)
1229
repo.dont_leave_lock_in_place()
871
SmartServerResponse(('LockContention',)), response)
1232
873
def test_lock_write_on_readonly_transport(self):
1233
874
backing = self.get_readonly_transport()
1234
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
875
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1235
876
branch = self.make_branch('.')
1236
877
root = self.get_transport().clone('/')
1237
878
path = urlutils.relative_url(root.base, self.get_transport().base)
1270
913
def test_unlock_on_unlocked_branch_unlocked_repo(self):
1271
914
backing = self.get_transport()
1272
request = smart_branch.SmartServerBranchRequestUnlock(backing)
915
request = smart.branch.SmartServerBranchRequestUnlock(backing)
1273
916
branch = self.make_branch('.', format='knit')
1274
917
response = request.execute(
1275
918
'', 'branch token', 'repo token')
1276
919
self.assertEqual(
1277
smart_req.SmartServerResponse(('TokenMismatch',)), response)
920
SmartServerResponse(('TokenMismatch',)), response)
1279
922
def test_unlock_on_unlocked_branch_locked_repo(self):
1280
923
backing = self.get_transport()
1281
request = smart_branch.SmartServerBranchRequestUnlock(backing)
924
request = smart.branch.SmartServerBranchRequestUnlock(backing)
1282
925
branch = self.make_branch('.', format='knit')
1283
926
# Lock the repository.
1284
repo_token = branch.repository.lock_write().repository_token
927
repo_token = branch.repository.lock_write()
1285
928
branch.repository.leave_lock_in_place()
1286
929
branch.repository.unlock()
1287
930
# Issue branch lock_write request on the unlocked branch (with locked
1289
response = request.execute('', 'branch token', repo_token)
932
response = request.execute(
933
'', 'branch token', repo_token)
1290
934
self.assertEqual(
1291
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1293
branch.repository.lock_write(repo_token)
1294
branch.repository.dont_leave_lock_in_place()
1295
branch.repository.unlock()
935
SmartServerResponse(('TokenMismatch',)), response)
1298
938
class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport):
1316
956
def test_trivial_bzipped(self):
1317
957
# This tests that the wire encoding is actually bzipped
1318
958
backing = self.get_transport()
1319
request = smart_repo.SmartServerRepositoryGetParentMap(backing)
959
request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1320
960
tree = self.make_branch_and_memory_tree('.')
1322
962
self.assertEqual(None,
1323
963
request.execute('', 'missing-id'))
1324
964
# Note that it returns a body that is bzipped.
1325
965
self.assertEqual(
1326
smart_req.SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
966
SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1327
967
request.do_body('\n\n0\n'))
1329
969
def test_trivial_include_missing(self):
1330
970
backing = self.get_transport()
1331
request = smart_repo.SmartServerRepositoryGetParentMap(backing)
971
request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1332
972
tree = self.make_branch_and_memory_tree('.')
1334
974
self.assertEqual(None,
1335
975
request.execute('', 'missing-id', 'include-missing:'))
1336
976
self.assertEqual(
1337
smart_req.SuccessfulSmartServerResponse(('ok', ),
977
SuccessfulSmartServerResponse(('ok', ),
1338
978
bz2.compress('missing:missing-id')),
1339
979
request.do_body('\n\n0\n'))
1342
class TestSmartServerRepositoryGetRevisionGraph(
1343
tests.TestCaseWithMemoryTransport):
982
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
1345
984
def test_none_argument(self):
1346
985
backing = self.get_transport()
1347
request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
986
request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1348
987
tree = self.make_branch_and_memory_tree('.')
1349
988
tree.lock_write()
1387
1026
# Note that it still returns body (of zero bytes).
1388
self.assertEqual(smart_req.SmartServerResponse(
1389
('nosuchrevision', 'missingrevision', ), ''),
1390
request.execute('', 'missingrevision'))
1393
class TestSmartServerRepositoryGetRevIdForRevno(
1394
tests.TestCaseWithMemoryTransport):
1396
def test_revno_found(self):
1397
backing = self.get_transport()
1398
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1399
tree = self.make_branch_and_memory_tree('.')
1402
rev1_id_utf8 = u'\xc8'.encode('utf-8')
1403
rev2_id_utf8 = u'\xc9'.encode('utf-8')
1404
tree.commit('1st commit', rev_id=rev1_id_utf8)
1405
tree.commit('2nd commit', rev_id=rev2_id_utf8)
1408
self.assertEqual(smart_req.SmartServerResponse(('ok', rev1_id_utf8)),
1409
request.execute('', 1, (2, rev2_id_utf8)))
1411
def test_known_revid_missing(self):
1412
backing = self.get_transport()
1413
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1414
repo = self.make_repository('.')
1416
smart_req.FailedSmartServerResponse(('nosuchrevision', 'ghost')),
1417
request.execute('', 1, (2, 'ghost')))
1419
def test_history_incomplete(self):
1420
backing = self.get_transport()
1421
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1422
parent = self.make_branch_and_memory_tree('parent', format='1.9')
1424
parent.add([''], ['TREE_ROOT'])
1425
r1 = parent.commit(message='first commit')
1426
r2 = parent.commit(message='second commit')
1428
local = self.make_branch_and_memory_tree('local', format='1.9')
1429
local.branch.pull(parent.branch)
1430
local.set_parent_ids([r2])
1431
r3 = local.commit(message='local commit')
1432
local.branch.create_clone_on_transport(
1433
self.get_transport('stacked'), stacked_on=self.get_url('parent'))
1435
smart_req.SmartServerResponse(('history-incomplete', 2, r2)),
1436
request.execute('stacked', 1, (3, r3)))
1028
SmartServerResponse(('nosuchrevision', 'missingrevision', ), ''),
1029
request.execute('', 'missingrevision'))
1439
1032
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1583
1176
def test_lock_write_on_unlocked_repo(self):
1584
1177
backing = self.get_transport()
1585
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1178
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1586
1179
repository = self.make_repository('.', format='knit')
1587
1180
response = request.execute('')
1588
1181
nonce = repository.control_files._lock.peek().get('nonce')
1589
self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
1182
self.assertEqual(SmartServerResponse(('ok', nonce)), response)
1590
1183
# The repository is now locked. Verify that with a new repository
1592
1185
new_repo = repository.bzrdir.open_repository()
1593
1186
self.assertRaises(errors.LockContention, new_repo.lock_write)
1595
request = smart_repo.SmartServerRepositoryUnlock(backing)
1596
response = request.execute('', nonce)
1598
1188
def test_lock_write_on_locked_repo(self):
1599
1189
backing = self.get_transport()
1600
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1190
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1601
1191
repository = self.make_repository('.', format='knit')
1602
repo_token = repository.lock_write().repository_token
1192
repository.lock_write()
1603
1193
repository.leave_lock_in_place()
1604
1194
repository.unlock()
1605
1195
response = request.execute('')
1606
1196
self.assertEqual(
1607
smart_req.SmartServerResponse(('LockContention',)), response)
1609
repository.lock_write(repo_token)
1610
repository.dont_leave_lock_in_place()
1197
SmartServerResponse(('LockContention',)), response)
1613
1199
def test_lock_write_on_readonly_transport(self):
1614
1200
backing = self.get_readonly_transport()
1615
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1201
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1616
1202
repository = self.make_repository('.', format='knit')
1617
1203
response = request.execute('')
1618
1204
self.assertFalse(response.is_successful())
1631
1217
def test_insert_stream_empty(self):
1632
1218
backing = self.get_transport()
1633
request = smart_repo.SmartServerRepositoryInsertStream(backing)
1219
request = smart.repository.SmartServerRepositoryInsertStream(backing)
1634
1220
repository = self.make_repository('.')
1635
1221
response = request.execute('', '')
1636
1222
self.assertEqual(None, response)
1637
1223
response = request.do_chunk(self.make_empty_byte_stream(repository))
1638
1224
self.assertEqual(None, response)
1639
1225
response = request.do_end()
1640
self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1226
self.assertEqual(SmartServerResponse(('ok', )), response)
1643
1229
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
1645
1231
def test_insert_stream_empty(self):
1646
1232
backing = self.get_transport()
1647
request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1233
request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1649
1235
repository = self.make_repository('.', format='knit')
1650
lock_token = repository.lock_write().repository_token
1236
lock_token = repository.lock_write()
1651
1237
response = request.execute('', '', lock_token)
1652
1238
self.assertEqual(None, response)
1653
1239
response = request.do_chunk(self.make_empty_byte_stream(repository))
1654
1240
self.assertEqual(None, response)
1655
1241
response = request.do_end()
1656
self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1242
self.assertEqual(SmartServerResponse(('ok', )), response)
1657
1243
repository.unlock()
1659
1245
def test_insert_stream_with_wrong_lock_token(self):
1660
1246
backing = self.get_transport()
1661
request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1247
request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1663
1249
repository = self.make_repository('.', format='knit')
1664
lock_token = repository.lock_write().repository_token
1250
lock_token = repository.lock_write()
1665
1251
self.assertRaises(
1666
1252
errors.TokenMismatch, request.execute, '', '', 'wrong-token')
1667
1253
repository.unlock()
1691
1277
def test_unlock_on_unlocked_repo(self):
1692
1278
backing = self.get_transport()
1693
request = smart_repo.SmartServerRepositoryUnlock(backing)
1279
request = smart.repository.SmartServerRepositoryUnlock(backing)
1694
1280
repository = self.make_repository('.', format='knit')
1695
1281
response = request.execute('', 'some token')
1696
1282
self.assertEqual(
1697
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1283
SmartServerResponse(('TokenMismatch',)), response)
1700
1286
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1702
1288
def test_is_readonly_no(self):
1703
1289
backing = self.get_transport()
1704
request = smart_req.SmartServerIsReadonly(backing)
1290
request = smart.request.SmartServerIsReadonly(backing)
1705
1291
response = request.execute()
1706
1292
self.assertEqual(
1707
smart_req.SmartServerResponse(('no',)), response)
1293
SmartServerResponse(('no',)), response)
1709
1295
def test_is_readonly_yes(self):
1710
1296
backing = self.get_readonly_transport()
1711
request = smart_req.SmartServerIsReadonly(backing)
1297
request = smart.request.SmartServerIsReadonly(backing)
1712
1298
response = request.execute()
1713
1299
self.assertEqual(
1714
smart_req.SmartServerResponse(('yes',)), response)
1717
class TestSmartServerRepositorySetMakeWorkingTrees(
1718
tests.TestCaseWithMemoryTransport):
1300
SmartServerResponse(('yes',)), response)
1303
class TestSmartServerRepositorySetMakeWorkingTrees(tests.TestCaseWithMemoryTransport):
1720
1305
def test_set_false(self):
1721
1306
backing = self.get_transport()
1722
1307
repo = self.make_repository('.', shared=True)
1723
1308
repo.set_make_working_trees(True)
1724
request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
1309
request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1725
1310
request = request_class(backing)
1726
self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
1311
self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1727
1312
request.execute('', 'False'))
1728
1313
repo = repo.bzrdir.open_repository()
1729
1314
self.assertFalse(repo.make_working_trees())
1811
1383
"""All registered request_handlers can be found."""
1812
1384
# If there's a typo in a register_lazy call, this loop will fail with
1813
1385
# an AttributeError.
1814
for key, item in smart_req.request_handlers.iteritems():
1386
for key, item in smart.request.request_handlers.iteritems():
1817
def assertHandlerEqual(self, verb, handler):
1818
self.assertEqual(smart_req.request_handlers.get(verb), handler)
1820
1389
def test_registered_methods(self):
1821
1390
"""Test that known methods are registered to the correct object."""
1822
self.assertHandlerEqual('Branch.get_config_file',
1823
smart_branch.SmartServerBranchGetConfigFile)
1824
self.assertHandlerEqual('Branch.get_parent',
1825
smart_branch.SmartServerBranchGetParent)
1826
self.assertHandlerEqual('Branch.get_tags_bytes',
1827
smart_branch.SmartServerBranchGetTagsBytes)
1828
self.assertHandlerEqual('Branch.lock_write',
1829
smart_branch.SmartServerBranchRequestLockWrite)
1830
self.assertHandlerEqual('Branch.last_revision_info',
1831
smart_branch.SmartServerBranchRequestLastRevisionInfo)
1832
self.assertHandlerEqual('Branch.revision_history',
1833
smart_branch.SmartServerRequestRevisionHistory)
1834
self.assertHandlerEqual('Branch.set_config_option',
1835
smart_branch.SmartServerBranchRequestSetConfigOption)
1836
self.assertHandlerEqual('Branch.set_last_revision',
1837
smart_branch.SmartServerBranchRequestSetLastRevision)
1838
self.assertHandlerEqual('Branch.set_last_revision_info',
1839
smart_branch.SmartServerBranchRequestSetLastRevisionInfo)
1840
self.assertHandlerEqual('Branch.set_last_revision_ex',
1841
smart_branch.SmartServerBranchRequestSetLastRevisionEx)
1842
self.assertHandlerEqual('Branch.set_parent_location',
1843
smart_branch.SmartServerBranchRequestSetParentLocation)
1844
self.assertHandlerEqual('Branch.unlock',
1845
smart_branch.SmartServerBranchRequestUnlock)
1846
self.assertHandlerEqual('BzrDir.find_repository',
1847
smart_dir.SmartServerRequestFindRepositoryV1)
1848
self.assertHandlerEqual('BzrDir.find_repositoryV2',
1849
smart_dir.SmartServerRequestFindRepositoryV2)
1850
self.assertHandlerEqual('BzrDirFormat.initialize',
1851
smart_dir.SmartServerRequestInitializeBzrDir)
1852
self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
1853
smart_dir.SmartServerRequestBzrDirInitializeEx)
1854
self.assertHandlerEqual('BzrDir.cloning_metadir',
1855
smart_dir.SmartServerBzrDirRequestCloningMetaDir)
1856
self.assertHandlerEqual('BzrDir.get_config_file',
1857
smart_dir.SmartServerBzrDirRequestConfigFile)
1858
self.assertHandlerEqual('BzrDir.open_branch',
1859
smart_dir.SmartServerRequestOpenBranch)
1860
self.assertHandlerEqual('BzrDir.open_branchV2',
1861
smart_dir.SmartServerRequestOpenBranchV2)
1862
self.assertHandlerEqual('BzrDir.open_branchV3',
1863
smart_dir.SmartServerRequestOpenBranchV3)
1864
self.assertHandlerEqual('PackRepository.autopack',
1865
smart_packrepo.SmartServerPackRepositoryAutopack)
1866
self.assertHandlerEqual('Repository.gather_stats',
1867
smart_repo.SmartServerRepositoryGatherStats)
1868
self.assertHandlerEqual('Repository.get_parent_map',
1869
smart_repo.SmartServerRepositoryGetParentMap)
1870
self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1871
smart_repo.SmartServerRepositoryGetRevIdForRevno)
1872
self.assertHandlerEqual('Repository.get_revision_graph',
1873
smart_repo.SmartServerRepositoryGetRevisionGraph)
1874
self.assertHandlerEqual('Repository.get_stream',
1875
smart_repo.SmartServerRepositoryGetStream)
1876
self.assertHandlerEqual('Repository.has_revision',
1877
smart_repo.SmartServerRequestHasRevision)
1878
self.assertHandlerEqual('Repository.insert_stream',
1879
smart_repo.SmartServerRepositoryInsertStream)
1880
self.assertHandlerEqual('Repository.insert_stream_locked',
1881
smart_repo.SmartServerRepositoryInsertStreamLocked)
1882
self.assertHandlerEqual('Repository.is_shared',
1883
smart_repo.SmartServerRepositoryIsShared)
1884
self.assertHandlerEqual('Repository.lock_write',
1885
smart_repo.SmartServerRepositoryLockWrite)
1886
self.assertHandlerEqual('Repository.tarball',
1887
smart_repo.SmartServerRepositoryTarball)
1888
self.assertHandlerEqual('Repository.unlock',
1889
smart_repo.SmartServerRepositoryUnlock)
1890
self.assertHandlerEqual('Transport.is_readonly',
1891
smart_req.SmartServerIsReadonly)
1392
smart.request.request_handlers.get('Branch.get_config_file'),
1393
smart.branch.SmartServerBranchGetConfigFile)
1395
smart.request.request_handlers.get('Branch.get_parent'),
1396
smart.branch.SmartServerBranchGetParent)
1398
smart.request.request_handlers.get('Branch.get_tags_bytes'),
1399
smart.branch.SmartServerBranchGetTagsBytes)
1401
smart.request.request_handlers.get('Branch.lock_write'),
1402
smart.branch.SmartServerBranchRequestLockWrite)
1404
smart.request.request_handlers.get('Branch.last_revision_info'),
1405
smart.branch.SmartServerBranchRequestLastRevisionInfo)
1407
smart.request.request_handlers.get('Branch.revision_history'),
1408
smart.branch.SmartServerRequestRevisionHistory)
1410
smart.request.request_handlers.get('Branch.set_config_option'),
1411
smart.branch.SmartServerBranchRequestSetConfigOption)
1413
smart.request.request_handlers.get('Branch.set_last_revision'),
1414
smart.branch.SmartServerBranchRequestSetLastRevision)
1416
smart.request.request_handlers.get('Branch.set_last_revision_info'),
1417
smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
1419
smart.request.request_handlers.get('Branch.unlock'),
1420
smart.branch.SmartServerBranchRequestUnlock)
1422
smart.request.request_handlers.get('BzrDir.find_repository'),
1423
smart.bzrdir.SmartServerRequestFindRepositoryV1)
1425
smart.request.request_handlers.get('BzrDir.find_repositoryV2'),
1426
smart.bzrdir.SmartServerRequestFindRepositoryV2)
1428
smart.request.request_handlers.get('BzrDirFormat.initialize'),
1429
smart.bzrdir.SmartServerRequestInitializeBzrDir)
1431
smart.request.request_handlers.get('BzrDir.cloning_metadir'),
1432
smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
1434
smart.request.request_handlers.get('BzrDir.open_branch'),
1435
smart.bzrdir.SmartServerRequestOpenBranch)
1437
smart.request.request_handlers.get('BzrDir.open_branchV2'),
1438
smart.bzrdir.SmartServerRequestOpenBranchV2)
1440
smart.request.request_handlers.get('PackRepository.autopack'),
1441
smart.packrepository.SmartServerPackRepositoryAutopack)
1443
smart.request.request_handlers.get('Repository.gather_stats'),
1444
smart.repository.SmartServerRepositoryGatherStats)
1446
smart.request.request_handlers.get('Repository.get_parent_map'),
1447
smart.repository.SmartServerRepositoryGetParentMap)
1449
smart.request.request_handlers.get(
1450
'Repository.get_revision_graph'),
1451
smart.repository.SmartServerRepositoryGetRevisionGraph)
1453
smart.request.request_handlers.get('Repository.get_stream'),
1454
smart.repository.SmartServerRepositoryGetStream)
1456
smart.request.request_handlers.get('Repository.has_revision'),
1457
smart.repository.SmartServerRequestHasRevision)
1459
smart.request.request_handlers.get('Repository.insert_stream'),
1460
smart.repository.SmartServerRepositoryInsertStream)
1462
smart.request.request_handlers.get('Repository.insert_stream_locked'),
1463
smart.repository.SmartServerRepositoryInsertStreamLocked)
1465
smart.request.request_handlers.get('Repository.is_shared'),
1466
smart.repository.SmartServerRepositoryIsShared)
1468
smart.request.request_handlers.get('Repository.lock_write'),
1469
smart.repository.SmartServerRepositoryLockWrite)
1471
smart.request.request_handlers.get('Repository.tarball'),
1472
smart.repository.SmartServerRepositoryTarball)
1474
smart.request.request_handlers.get('Repository.unlock'),
1475
smart.repository.SmartServerRepositoryUnlock)
1477
smart.request.request_handlers.get('Transport.is_readonly'),
1478
smart.request.SmartServerIsReadonly)
added
removed
bzrlib/tests/test_smart.py
