31
31
from bzrlib import (
33
branch as _mod_branch,
41
from bzrlib.branch import Branch, BranchReferenceFormat
42
import bzrlib.smart.branch
43
import bzrlib.smart.bzrdir, bzrlib.smart.bzrdir as smart_dir
44
import bzrlib.smart.packrepository
45
import bzrlib.smart.repository
46
import bzrlib.smart.vfs
47
from bzrlib.smart.request import (
48
FailedSmartServerResponse,
51
SuccessfulSmartServerResponse,
53
from bzrlib.tests import (
56
from bzrlib.transport import chroot, get_transport, local, memory
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 (
59
58
def load_tests(standard_tests, module, loader):
60
59
"""Multiply tests version and protocol consistency."""
61
60
# FindRepository tests.
62
bzrdir_mod = bzrlib.smart.bzrdir
64
62
("find_repository", {
65
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV1}),
63
"_request_class": smart_dir.SmartServerRequestFindRepositoryV1}),
66
64
("find_repositoryV2", {
67
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV2}),
65
"_request_class": smart_dir.SmartServerRequestFindRepositoryV2}),
68
66
("find_repositoryV3", {
69
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV3}),
67
"_request_class": smart_dir.SmartServerRequestFindRepositoryV3}),
71
to_adapt, result = split_suite_by_re(standard_tests,
69
to_adapt, result = tests.split_suite_by_re(standard_tests,
72
70
"TestSmartServerRequestFindRepository")
73
v2_only, v1_and_2 = split_suite_by_re(to_adapt,
71
v2_only, v1_and_2 = tests.split_suite_by_re(to_adapt,
75
73
tests.multiply_tests(v1_and_2, scenarios, result)
76
74
# The first scenario is only applicable to v1 protocols, it is deleted
137
135
class TestSmartServerResponse(tests.TestCase):
139
137
def test__eq__(self):
140
self.assertEqual(SmartServerResponse(('ok', )),
141
SmartServerResponse(('ok', )))
142
self.assertEqual(SmartServerResponse(('ok', ), 'body'),
143
SmartServerResponse(('ok', ), 'body'))
144
self.assertNotEqual(SmartServerResponse(('ok', )),
145
SmartServerResponse(('notok', )))
146
self.assertNotEqual(SmartServerResponse(('ok', ), 'body'),
147
SmartServerResponse(('ok', )))
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', )))
148
146
self.assertNotEqual(None,
149
SmartServerResponse(('ok', )))
147
smart_req.SmartServerResponse(('ok', )))
151
149
def test__str__(self):
152
150
"""SmartServerResponses can be stringified."""
153
151
self.assertEqual(
154
152
"<SuccessfulSmartServerResponse args=('args',) body='body'>",
155
str(SuccessfulSmartServerResponse(('args',), 'body')))
153
str(smart_req.SuccessfulSmartServerResponse(('args',), 'body')))
156
154
self.assertEqual(
157
155
"<FailedSmartServerResponse args=('args',) body='body'>",
158
str(FailedSmartServerResponse(('args',), 'body')))
156
str(smart_req.FailedSmartServerResponse(('args',), 'body')))
161
159
class TestSmartServerRequest(tests.TestCaseWithMemoryTransport):
163
161
def test_translate_client_path(self):
164
162
transport = self.get_transport()
165
request = SmartServerRequest(transport, 'foo/')
163
request = smart_req.SmartServerRequest(transport, 'foo/')
166
164
self.assertEqual('./', request.translate_client_path('foo/'))
167
165
self.assertRaises(
168
166
errors.InvalidURLJoin, request.translate_client_path, 'foo/..')
287
if (smart.bzrdir.SmartServerRequestFindRepositoryV3 ==
286
if (smart_dir.SmartServerRequestFindRepositoryV3 ==
288
287
self._request_class):
289
return SuccessfulSmartServerResponse(
288
return smart_req.SuccessfulSmartServerResponse(
290
289
('ok', '', rich_root, subtrees, external,
291
290
repo._format.network_name()))
292
elif (smart.bzrdir.SmartServerRequestFindRepositoryV2 ==
291
elif (smart_dir.SmartServerRequestFindRepositoryV2 ==
293
292
self._request_class):
294
293
# All tests so far are on formats, and for non-external
296
return SuccessfulSmartServerResponse(
295
return smart_req.SuccessfulSmartServerResponse(
297
296
('ok', '', rich_root, subtrees, external))
299
return SuccessfulSmartServerResponse(('ok', '', rich_root, subtrees))
298
return smart_req.SuccessfulSmartServerResponse(
299
('ok', '', rich_root, subtrees))
301
301
def test_shared_repository(self):
302
302
"""When there is a shared repository, we get 'ok', 'relpath-to-repo'."""
421
427
"""Initializing an extant directory should fail like the bzrdir api."""
422
428
backing = self.get_transport()
423
429
name = self.make_bzrdir('reference')._format.network_name()
424
request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)
430
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
425
431
self.make_bzrdir('subdir')
426
432
self.assertRaises(errors.FileExists, request.execute, name, 'subdir',
427
433
'False', 'False', 'False', '', '', '', '', 'False')
430
436
class TestSmartServerRequestOpenBzrDir(tests.TestCaseWithMemoryTransport):
432
438
def test_no_directory(self):
433
439
backing = self.get_transport()
434
request = smart.bzrdir.SmartServerRequestOpenBzrDir(backing)
435
self.assertEqual(SmartServerResponse(('no', )),
440
request = smart_dir.SmartServerRequestOpenBzrDir(backing)
441
self.assertEqual(smart_req.SmartServerResponse(('no', )),
436
442
request.execute('does-not-exist'))
438
444
def test_empty_directory(self):
439
445
backing = self.get_transport()
440
446
backing.mkdir('empty')
441
request = smart.bzrdir.SmartServerRequestOpenBzrDir(backing)
442
self.assertEqual(SmartServerResponse(('no', )),
447
request = smart_dir.SmartServerRequestOpenBzrDir(backing)
448
self.assertEqual(smart_req.SmartServerResponse(('no', )),
443
449
request.execute('empty'))
445
451
def test_outside_root_client_path(self):
446
452
backing = self.get_transport()
447
request = smart.bzrdir.SmartServerRequestOpenBzrDir(backing,
453
request = smart_dir.SmartServerRequestOpenBzrDir(backing,
448
454
root_client_path='root')
449
self.assertEqual(SmartServerResponse(('no', )),
455
self.assertEqual(smart_req.SmartServerResponse(('no', )),
450
456
request.execute('not-root'))
453
459
class TestSmartServerRequestOpenBzrDir_2_1(tests.TestCaseWithMemoryTransport):
455
461
def test_no_directory(self):
456
462
backing = self.get_transport()
457
request = smart.bzrdir.SmartServerRequestOpenBzrDir_2_1(backing)
458
self.assertEqual(SmartServerResponse(('no', )),
463
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
464
self.assertEqual(smart_req.SmartServerResponse(('no', )),
459
465
request.execute('does-not-exist'))
461
467
def test_empty_directory(self):
462
468
backing = self.get_transport()
463
469
backing.mkdir('empty')
464
request = smart.bzrdir.SmartServerRequestOpenBzrDir_2_1(backing)
465
self.assertEqual(SmartServerResponse(('no', )),
470
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
471
self.assertEqual(smart_req.SmartServerResponse(('no', )),
466
472
request.execute('empty'))
468
474
def test_present_without_workingtree(self):
469
475
backing = self.get_transport()
470
request = smart.bzrdir.SmartServerRequestOpenBzrDir_2_1(backing)
476
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
471
477
self.make_bzrdir('.')
472
self.assertEqual(SmartServerResponse(('yes', 'no')),
478
self.assertEqual(smart_req.SmartServerResponse(('yes', 'no')),
473
479
request.execute(''))
475
481
def test_outside_root_client_path(self):
476
482
backing = self.get_transport()
477
request = smart.bzrdir.SmartServerRequestOpenBzrDir_2_1(backing,
483
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing,
478
484
root_client_path='root')
479
self.assertEqual(SmartServerResponse(('no',)),
485
self.assertEqual(smart_req.SmartServerResponse(('no',)),
480
486
request.execute('not-root'))
483
489
class TestSmartServerRequestOpenBzrDir_2_1_disk(TestCaseWithChrootedTransport):
485
491
def test_present_with_workingtree(self):
486
self.vfs_transport_factory = local.LocalURLServer
492
self.vfs_transport_factory = test_server.LocalURLServer
487
493
backing = self.get_transport()
488
request = smart.bzrdir.SmartServerRequestOpenBzrDir_2_1(backing)
494
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
489
495
bd = self.make_bzrdir('.')
490
496
bd.create_repository()
491
497
bd.create_branch()
492
498
bd.create_workingtree()
493
self.assertEqual(SmartServerResponse(('yes', 'yes')),
499
self.assertEqual(smart_req.SmartServerResponse(('yes', 'yes')),
494
500
request.execute(''))
499
505
def test_no_branch(self):
500
506
"""When there is no branch, ('nobranch', ) is returned."""
501
507
backing = self.get_transport()
502
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
508
request = smart_dir.SmartServerRequestOpenBranch(backing)
503
509
self.make_bzrdir('.')
504
self.assertEqual(SmartServerResponse(('nobranch', )),
510
self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
505
511
request.execute(''))
507
513
def test_branch(self):
508
514
"""When there is a branch, 'ok' is returned."""
509
515
backing = self.get_transport()
510
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
516
request = smart_dir.SmartServerRequestOpenBranch(backing)
511
517
self.make_branch('.')
512
self.assertEqual(SmartServerResponse(('ok', '')),
518
self.assertEqual(smart_req.SmartServerResponse(('ok', '')),
513
519
request.execute(''))
515
521
def test_branch_reference(self):
516
522
"""When there is a branch reference, the reference URL is returned."""
517
self.vfs_transport_factory = local.LocalURLServer
523
self.vfs_transport_factory = test_server.LocalURLServer
518
524
backing = self.get_transport()
519
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
525
request = smart_dir.SmartServerRequestOpenBranch(backing)
520
526
branch = self.make_branch('branch')
521
527
checkout = branch.create_checkout('reference',lightweight=True)
522
reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
528
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
523
530
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
524
self.assertEqual(SmartServerResponse(('ok', reference_url)),
531
self.assertEqual(smart_req.SmartServerResponse(('ok', reference_url)),
525
532
request.execute('reference'))
527
534
def test_notification_on_branch_from_repository(self):
528
535
"""When there is a repository, the error should return details."""
529
536
backing = self.get_transport()
530
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
537
request = smart_dir.SmartServerRequestOpenBranch(backing)
531
538
repo = self.make_repository('.')
532
self.assertEqual(SmartServerResponse(('nobranch',)),
539
self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
533
540
request.execute(''))
539
546
"""When there is no branch, ('nobranch', ) is returned."""
540
547
backing = self.get_transport()
541
548
self.make_bzrdir('.')
542
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
543
self.assertEqual(SmartServerResponse(('nobranch', )),
549
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
550
self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
544
551
request.execute(''))
546
553
def test_branch(self):
547
554
"""When there is a branch, 'ok' is returned."""
548
555
backing = self.get_transport()
549
556
expected = self.make_branch('.')._format.network_name()
550
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
551
self.assertEqual(SuccessfulSmartServerResponse(('branch', expected)),
557
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
558
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
559
('branch', expected)),
554
562
def test_branch_reference(self):
555
563
"""When there is a branch reference, the reference URL is returned."""
556
self.vfs_transport_factory = local.LocalURLServer
564
self.vfs_transport_factory = test_server.LocalURLServer
557
565
backing = self.get_transport()
558
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
566
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
559
567
branch = self.make_branch('branch')
560
568
checkout = branch.create_checkout('reference',lightweight=True)
561
reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
569
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
562
571
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
563
self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
564
request.execute('reference'))
572
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
573
('ref', reference_url)),
574
request.execute('reference'))
566
576
def test_stacked_branch(self):
567
577
"""Opening a stacked branch does not open the stacked-on branch."""
569
579
feature = self.make_branch('feature')
570
580
feature.set_stacked_on_url(trunk.base)
571
581
opened_branches = []
572
Branch.hooks.install_named_hook('open', opened_branches.append, None)
582
_mod_branch.Branch.hooks.install_named_hook(
583
'open', opened_branches.append, None)
573
584
backing = self.get_transport()
574
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
585
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
575
586
request.setup_jail()
577
588
response = request.execute('feature')
579
590
request.teardown_jail()
580
591
expected_format = feature._format.network_name()
582
SuccessfulSmartServerResponse(('branch', expected_format)),
592
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
593
('branch', expected_format)),
584
595
self.assertLength(1, opened_branches)
586
597
def test_notification_on_branch_from_repository(self):
587
598
"""When there is a repository, the error should return details."""
588
599
backing = self.get_transport()
589
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
600
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
590
601
repo = self.make_repository('.')
591
self.assertEqual(SmartServerResponse(('nobranch',)),
602
self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
592
603
request.execute(''))
598
609
"""When there is no branch, ('nobranch', ) is returned."""
599
610
backing = self.get_transport()
600
611
self.make_bzrdir('.')
601
request = smart.bzrdir.SmartServerRequestOpenBranchV3(backing)
602
self.assertEqual(SmartServerResponse(('nobranch',)),
612
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
613
self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
603
614
request.execute(''))
605
616
def test_branch(self):
606
617
"""When there is a branch, 'ok' is returned."""
607
618
backing = self.get_transport()
608
619
expected = self.make_branch('.')._format.network_name()
609
request = smart.bzrdir.SmartServerRequestOpenBranchV3(backing)
610
self.assertEqual(SuccessfulSmartServerResponse(('branch', expected)),
620
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
621
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
622
('branch', expected)),
613
625
def test_branch_reference(self):
614
626
"""When there is a branch reference, the reference URL is returned."""
615
self.vfs_transport_factory = local.LocalURLServer
627
self.vfs_transport_factory = test_server.LocalURLServer
616
628
backing = self.get_transport()
617
request = smart.bzrdir.SmartServerRequestOpenBranchV3(backing)
629
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
618
630
branch = self.make_branch('branch')
619
631
checkout = branch.create_checkout('reference',lightweight=True)
620
reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
632
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
621
634
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
622
self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
623
request.execute('reference'))
635
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
636
('ref', reference_url)),
637
request.execute('reference'))
625
639
def test_stacked_branch(self):
626
640
"""Opening a stacked branch does not open the stacked-on branch."""
628
642
feature = self.make_branch('feature')
629
643
feature.set_stacked_on_url(trunk.base)
630
644
opened_branches = []
631
Branch.hooks.install_named_hook('open', opened_branches.append, None)
645
_mod_branch.Branch.hooks.install_named_hook(
646
'open', opened_branches.append, None)
632
647
backing = self.get_transport()
633
request = smart.bzrdir.SmartServerRequestOpenBranchV3(backing)
648
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
634
649
request.setup_jail()
636
651
response = request.execute('feature')
638
653
request.teardown_jail()
639
654
expected_format = feature._format.network_name()
641
SuccessfulSmartServerResponse(('branch', expected_format)),
655
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
656
('branch', expected_format)),
643
658
self.assertLength(1, opened_branches)
645
660
def test_notification_on_branch_from_repository(self):
646
661
"""When there is a repository, the error should return details."""
647
662
backing = self.get_transport()
648
request = smart.bzrdir.SmartServerRequestOpenBranchV3(backing)
663
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
649
664
repo = self.make_repository('.')
651
SmartServerResponse(('nobranch', 'location is a repository')),
665
self.assertEqual(smart_req.SmartServerResponse(
666
('nobranch', 'location is a repository')),
655
670
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
690
705
def test_branch_reference(self):
691
706
"""When there is a branch reference, NotBranchError is raised."""
692
707
backing = self.get_transport()
693
request = smart.branch.SmartServerBranchRequest(backing)
708
request = smart_branch.SmartServerBranchRequest(backing)
694
709
branch = self.make_branch('branch')
695
710
checkout = branch.create_checkout('reference',lightweight=True)
696
711
self.assertRaises(errors.NotBranchError,
697
712
request.execute, 'checkout')
700
class TestSmartServerBranchRequestLastRevisionInfo(tests.TestCaseWithMemoryTransport):
715
class TestSmartServerBranchRequestLastRevisionInfo(
716
tests.TestCaseWithMemoryTransport):
702
718
def test_empty(self):
703
719
"""For an empty branch, the result is ('ok', '0', 'null:')."""
704
720
backing = self.get_transport()
705
request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
721
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
706
722
self.make_branch('.')
707
self.assertEqual(SmartServerResponse(('ok', '0', 'null:')),
723
self.assertEqual(smart_req.SmartServerResponse(('ok', '0', 'null:')),
708
724
request.execute(''))
710
726
def test_not_empty(self):
711
727
"""For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
712
728
backing = self.get_transport()
713
request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
729
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
714
730
tree = self.make_branch_and_memory_tree('.')
715
731
tree.lock_write()
761
778
def test_value_name(self):
762
779
branch = self.make_branch('.')
763
request = smart.branch.SmartServerBranchRequestSetConfigOption(
780
request = smart_branch.SmartServerBranchRequestSetConfigOption(
764
781
branch.bzrdir.root_transport)
765
782
branch_token, repo_token = self.get_lock_tokens(branch)
766
783
config = branch._get_config()
767
784
result = request.execute('', branch_token, repo_token, 'bar', 'foo',
769
self.assertEqual(SuccessfulSmartServerResponse(()), result)
786
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
770
787
self.assertEqual('bar', config.get_option('foo'))
774
791
def test_value_name_section(self):
775
792
branch = self.make_branch('.')
776
request = smart.branch.SmartServerBranchRequestSetConfigOption(
793
request = smart_branch.SmartServerBranchRequestSetConfigOption(
777
794
branch.bzrdir.root_transport)
778
795
branch_token, repo_token = self.get_lock_tokens(branch)
779
796
config = branch._get_config()
780
797
result = request.execute('', branch_token, repo_token, 'bar', 'foo',
782
self.assertEqual(SuccessfulSmartServerResponse(()), result)
799
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
783
800
self.assertEqual('bar', config.get_option('foo', 'gam'))
805
class TestSmartServerBranchRequestSetConfigOptionDict(TestLockedBranch):
808
TestLockedBranch.setUp(self)
809
# A dict with non-ascii keys and values to exercise unicode
811
self.encoded_value_dict = (
812
'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde')
814
'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
816
def test_value_name(self):
817
branch = self.make_branch('.')
818
request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
819
branch.bzrdir.root_transport)
820
branch_token, repo_token = self.get_lock_tokens(branch)
821
config = branch._get_config()
822
result = request.execute('', branch_token, repo_token,
823
self.encoded_value_dict, 'foo', '')
824
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
825
self.assertEqual(self.value_dict, config.get_option('foo'))
829
def test_value_name_section(self):
830
branch = self.make_branch('.')
831
request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
832
branch.bzrdir.root_transport)
833
branch_token, repo_token = self.get_lock_tokens(branch)
834
config = branch._get_config()
835
result = request.execute('', branch_token, repo_token,
836
self.encoded_value_dict, 'foo', 'gam')
837
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
838
self.assertEqual(self.value_dict, config.get_option('foo', 'gam'))
788
843
class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):
789
844
# Only called when the branch format and tags match [yay factory
790
845
# methods] so only need to test straight forward cases.
1041
1097
def test_get_parent_none(self):
1042
1098
base_branch = self.make_branch('base')
1043
request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1099
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
1044
1100
response = request.execute('base')
1045
1101
self.assertEquals(
1046
SuccessfulSmartServerResponse(('',)), response)
1102
smart_req.SuccessfulSmartServerResponse(('',)), response)
1048
1104
def test_get_parent_something(self):
1049
1105
base_branch = self.make_branch('base')
1050
1106
base_branch.set_parent(self.get_url('foo'))
1051
request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1107
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
1052
1108
response = request.execute('base')
1053
1109
self.assertEquals(
1054
SuccessfulSmartServerResponse(("../foo",)),
1110
smart_req.SuccessfulSmartServerResponse(("../foo",)),
1058
class TestSmartServerBranchRequestSetParent(tests.TestCaseWithMemoryTransport):
1114
class TestSmartServerBranchRequestSetParent(TestLockedBranch):
1060
1116
def test_set_parent_none(self):
1061
1117
branch = self.make_branch('base', format="1.9")
1062
1118
branch.lock_write()
1063
1119
branch._set_parent_location('foo')
1064
1120
branch.unlock()
1065
request = smart.branch.SmartServerBranchRequestSetParentLocation(
1121
request = smart_branch.SmartServerBranchRequestSetParentLocation(
1066
1122
self.get_transport())
1067
branch_token = branch.lock_write()
1068
repo_token = branch.repository.lock_write()
1123
branch_token, repo_token = self.get_lock_tokens(branch)
1070
1125
response = request.execute('base', branch_token, repo_token, '')
1072
branch.repository.unlock()
1073
1127
branch.unlock()
1074
self.assertEqual(SuccessfulSmartServerResponse(()), response)
1128
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1075
1129
self.assertEqual(None, branch.get_parent())
1077
1131
def test_set_parent_something(self):
1078
1132
branch = self.make_branch('base', format="1.9")
1079
request = smart.branch.SmartServerBranchRequestSetParentLocation(
1133
request = smart_branch.SmartServerBranchRequestSetParentLocation(
1080
1134
self.get_transport())
1081
branch_token = branch.lock_write()
1082
repo_token = branch.repository.lock_write()
1135
branch_token, repo_token = self.get_lock_tokens(branch)
1084
1137
response = request.execute('base', branch_token, repo_token,
1087
branch.repository.unlock()
1088
1140
branch.unlock()
1089
self.assertEqual(SuccessfulSmartServerResponse(()), response)
1141
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1090
1142
self.assertEqual('http://bar/', branch.get_parent())
1093
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
1145
class TestSmartServerBranchRequestGetTagsBytes(
1146
tests.TestCaseWithMemoryTransport):
1094
1147
# Only called when the branch format and tags match [yay factory
1095
1148
# methods] so only need to test straight forward cases.
1097
1150
def test_get_bytes(self):
1098
1151
base_branch = self.make_branch('base')
1099
request = smart.branch.SmartServerBranchGetTagsBytes(
1152
request = smart_branch.SmartServerBranchGetTagsBytes(
1100
1153
self.get_transport())
1101
1154
response = request.execute('base')
1102
1155
self.assertEquals(
1103
SuccessfulSmartServerResponse(('',)), response)
1156
smart_req.SuccessfulSmartServerResponse(('',)), response)
1106
1159
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
1110
1163
stacked_branch = self.make_branch('stacked', format='1.6')
1111
1164
# typically should be relative
1112
1165
stacked_branch.set_stacked_on_url('../base')
1113
request = smart.branch.SmartServerBranchRequestGetStackedOnURL(
1166
request = smart_branch.SmartServerBranchRequestGetStackedOnURL(
1114
1167
self.get_transport())
1115
1168
response = request.execute('stacked')
1116
1169
self.assertEquals(
1117
SmartServerResponse(('ok', '../base')),
1170
smart_req.SmartServerResponse(('ok', '../base')),
1121
class TestSmartServerBranchRequestLockWrite(tests.TestCaseWithMemoryTransport):
1174
class TestSmartServerBranchRequestLockWrite(TestLockedBranch):
1123
1176
def setUp(self):
1124
1177
tests.TestCaseWithMemoryTransport.setUp(self)
1126
1179
def test_lock_write_on_unlocked_branch(self):
1127
1180
backing = self.get_transport()
1128
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1181
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1129
1182
branch = self.make_branch('.', format='knit')
1130
1183
repository = branch.repository
1131
1184
response = request.execute('')
1132
1185
branch_nonce = branch.control_files._lock.peek().get('nonce')
1133
1186
repository_nonce = repository.control_files._lock.peek().get('nonce')
1135
SmartServerResponse(('ok', branch_nonce, repository_nonce)),
1187
self.assertEqual(smart_req.SmartServerResponse(
1188
('ok', branch_nonce, repository_nonce)),
1137
1190
# The branch (and associated repository) is now locked. Verify that
1138
1191
# with a new branch object.
1139
1192
new_branch = repository.bzrdir.open_branch()
1140
1193
self.assertRaises(errors.LockContention, new_branch.lock_write)
1142
request = smart.branch.SmartServerBranchRequestUnlock(backing)
1195
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1143
1196
response = request.execute('', branch_nonce, repository_nonce)
1145
1198
def test_lock_write_on_locked_branch(self):
1146
1199
backing = self.get_transport()
1147
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1200
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1148
1201
branch = self.make_branch('.')
1149
branch_token = branch.lock_write()
1202
branch_token = branch.lock_write().branch_token
1150
1203
branch.leave_lock_in_place()
1151
1204
branch.unlock()
1152
1205
response = request.execute('')
1153
1206
self.assertEqual(
1154
SmartServerResponse(('LockContention',)), response)
1207
smart_req.SmartServerResponse(('LockContention',)), response)
1156
1209
branch.lock_write(branch_token)
1157
1210
branch.dont_leave_lock_in_place()
1260
1308
def test_unlock_on_unlocked_branch_unlocked_repo(self):
1261
1309
backing = self.get_transport()
1262
request = smart.branch.SmartServerBranchRequestUnlock(backing)
1310
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1263
1311
branch = self.make_branch('.', format='knit')
1264
1312
response = request.execute(
1265
1313
'', 'branch token', 'repo token')
1266
1314
self.assertEqual(
1267
SmartServerResponse(('TokenMismatch',)), response)
1315
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1269
1317
def test_unlock_on_unlocked_branch_locked_repo(self):
1270
1318
backing = self.get_transport()
1271
request = smart.branch.SmartServerBranchRequestUnlock(backing)
1319
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1272
1320
branch = self.make_branch('.', format='knit')
1273
1321
# Lock the repository.
1274
repo_token = branch.repository.lock_write()
1322
repo_token = branch.repository.lock_write().repository_token
1275
1323
branch.repository.leave_lock_in_place()
1276
1324
branch.repository.unlock()
1277
1325
# Issue branch lock_write request on the unlocked branch (with locked
1279
response = request.execute(
1280
'', 'branch token', repo_token)
1327
response = request.execute('', 'branch token', repo_token)
1281
1328
self.assertEqual(
1282
SmartServerResponse(('TokenMismatch',)), response)
1329
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1284
1331
branch.repository.lock_write(repo_token)
1285
1332
branch.repository.dont_leave_lock_in_place()
1307
1354
def test_trivial_bzipped(self):
1308
1355
# This tests that the wire encoding is actually bzipped
1309
1356
backing = self.get_transport()
1310
request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1357
request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1311
1358
tree = self.make_branch_and_memory_tree('.')
1313
1360
self.assertEqual(None,
1314
1361
request.execute('', 'missing-id'))
1315
1362
# Note that it returns a body that is bzipped.
1316
1363
self.assertEqual(
1317
SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1364
smart_req.SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1318
1365
request.do_body('\n\n0\n'))
1320
1367
def test_trivial_include_missing(self):
1321
1368
backing = self.get_transport()
1322
request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1369
request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1323
1370
tree = self.make_branch_and_memory_tree('.')
1325
1372
self.assertEqual(None,
1326
1373
request.execute('', 'missing-id', 'include-missing:'))
1327
1374
self.assertEqual(
1328
SuccessfulSmartServerResponse(('ok', ),
1375
smart_req.SuccessfulSmartServerResponse(('ok', ),
1329
1376
bz2.compress('missing:missing-id')),
1330
1377
request.do_body('\n\n0\n'))
1333
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
1380
class TestSmartServerRepositoryGetRevisionGraph(
1381
tests.TestCaseWithMemoryTransport):
1335
1383
def test_none_argument(self):
1336
1384
backing = self.get_transport()
1337
request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1385
request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
1338
1386
tree = self.make_branch_and_memory_tree('.')
1339
1387
tree.lock_write()
1394
1443
tree.commit('2nd commit', rev_id=rev2_id_utf8)
1397
self.assertEqual(SmartServerResponse(('ok', rev1_id_utf8)),
1446
self.assertEqual(smart_req.SmartServerResponse(('ok', rev1_id_utf8)),
1398
1447
request.execute('', 1, (2, rev2_id_utf8)))
1400
1449
def test_known_revid_missing(self):
1401
1450
backing = self.get_transport()
1402
request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
1451
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1403
1452
repo = self.make_repository('.')
1404
1453
self.assertEqual(
1405
FailedSmartServerResponse(('nosuchrevision', 'ghost')),
1454
smart_req.FailedSmartServerResponse(('nosuchrevision', 'ghost')),
1406
1455
request.execute('', 1, (2, 'ghost')))
1408
1457
def test_history_incomplete(self):
1409
1458
backing = self.get_transport()
1410
request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
1459
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1411
1460
parent = self.make_branch_and_memory_tree('parent', format='1.9')
1412
1461
parent.lock_write()
1413
1462
parent.add([''], ['TREE_ROOT'])
1572
1621
def test_lock_write_on_unlocked_repo(self):
1573
1622
backing = self.get_transport()
1574
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1623
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1575
1624
repository = self.make_repository('.', format='knit')
1576
1625
response = request.execute('')
1577
1626
nonce = repository.control_files._lock.peek().get('nonce')
1578
self.assertEqual(SmartServerResponse(('ok', nonce)), response)
1627
self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
1579
1628
# The repository is now locked. Verify that with a new repository
1581
1630
new_repo = repository.bzrdir.open_repository()
1582
1631
self.assertRaises(errors.LockContention, new_repo.lock_write)
1584
request = smart.repository.SmartServerRepositoryUnlock(backing)
1633
request = smart_repo.SmartServerRepositoryUnlock(backing)
1585
1634
response = request.execute('', nonce)
1587
1636
def test_lock_write_on_locked_repo(self):
1588
1637
backing = self.get_transport()
1589
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1638
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1590
1639
repository = self.make_repository('.', format='knit')
1591
repo_token = repository.lock_write()
1640
repo_token = repository.lock_write().repository_token
1592
1641
repository.leave_lock_in_place()
1593
1642
repository.unlock()
1594
1643
response = request.execute('')
1595
1644
self.assertEqual(
1596
SmartServerResponse(('LockContention',)), response)
1645
smart_req.SmartServerResponse(('LockContention',)), response)
1598
1647
repository.lock_write(repo_token)
1599
1648
repository.dont_leave_lock_in_place()
1620
1669
def test_insert_stream_empty(self):
1621
1670
backing = self.get_transport()
1622
request = smart.repository.SmartServerRepositoryInsertStream(backing)
1671
request = smart_repo.SmartServerRepositoryInsertStream(backing)
1623
1672
repository = self.make_repository('.')
1624
1673
response = request.execute('', '')
1625
1674
self.assertEqual(None, response)
1626
1675
response = request.do_chunk(self.make_empty_byte_stream(repository))
1627
1676
self.assertEqual(None, response)
1628
1677
response = request.do_end()
1629
self.assertEqual(SmartServerResponse(('ok', )), response)
1678
self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1632
1681
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
1634
1683
def test_insert_stream_empty(self):
1635
1684
backing = self.get_transport()
1636
request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1685
request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1638
1687
repository = self.make_repository('.', format='knit')
1639
lock_token = repository.lock_write()
1688
lock_token = repository.lock_write().repository_token
1640
1689
response = request.execute('', '', lock_token)
1641
1690
self.assertEqual(None, response)
1642
1691
response = request.do_chunk(self.make_empty_byte_stream(repository))
1643
1692
self.assertEqual(None, response)
1644
1693
response = request.do_end()
1645
self.assertEqual(SmartServerResponse(('ok', )), response)
1694
self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1646
1695
repository.unlock()
1648
1697
def test_insert_stream_with_wrong_lock_token(self):
1649
1698
backing = self.get_transport()
1650
request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1699
request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1652
1701
repository = self.make_repository('.', format='knit')
1653
lock_token = repository.lock_write()
1702
lock_token = repository.lock_write().repository_token
1654
1703
self.assertRaises(
1655
1704
errors.TokenMismatch, request.execute, '', '', 'wrong-token')
1656
1705
repository.unlock()
1680
1729
def test_unlock_on_unlocked_repo(self):
1681
1730
backing = self.get_transport()
1682
request = smart.repository.SmartServerRepositoryUnlock(backing)
1731
request = smart_repo.SmartServerRepositoryUnlock(backing)
1683
1732
repository = self.make_repository('.', format='knit')
1684
1733
response = request.execute('', 'some token')
1685
1734
self.assertEqual(
1686
SmartServerResponse(('TokenMismatch',)), response)
1735
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1689
1738
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1691
1740
def test_is_readonly_no(self):
1692
1741
backing = self.get_transport()
1693
request = smart.request.SmartServerIsReadonly(backing)
1742
request = smart_req.SmartServerIsReadonly(backing)
1694
1743
response = request.execute()
1695
1744
self.assertEqual(
1696
SmartServerResponse(('no',)), response)
1745
smart_req.SmartServerResponse(('no',)), response)
1698
1747
def test_is_readonly_yes(self):
1699
1748
backing = self.get_readonly_transport()
1700
request = smart.request.SmartServerIsReadonly(backing)
1749
request = smart_req.SmartServerIsReadonly(backing)
1701
1750
response = request.execute()
1702
1751
self.assertEqual(
1703
SmartServerResponse(('yes',)), response)
1706
class TestSmartServerRepositorySetMakeWorkingTrees(tests.TestCaseWithMemoryTransport):
1752
smart_req.SmartServerResponse(('yes',)), response)
1755
class TestSmartServerRepositorySetMakeWorkingTrees(
1756
tests.TestCaseWithMemoryTransport):
1708
1758
def test_set_false(self):
1709
1759
backing = self.get_transport()
1710
1760
repo = self.make_repository('.', shared=True)
1711
1761
repo.set_make_working_trees(True)
1712
request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1762
request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
1713
1763
request = request_class(backing)
1714
self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1764
self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
1715
1765
request.execute('', 'False'))
1716
1766
repo = repo.bzrdir.open_repository()
1717
1767
self.assertFalse(repo.make_working_trees())
1799
1849
"""All registered request_handlers can be found."""
1800
1850
# If there's a typo in a register_lazy call, this loop will fail with
1801
1851
# an AttributeError.
1802
for key, item in smart.request.request_handlers.iteritems():
1852
for key, item in smart_req.request_handlers.iteritems():
1805
1855
def assertHandlerEqual(self, verb, handler):
1806
self.assertEqual(smart.request.request_handlers.get(verb), handler)
1856
self.assertEqual(smart_req.request_handlers.get(verb), handler)
1808
1858
def test_registered_methods(self):
1809
1859
"""Test that known methods are registered to the correct object."""
1810
1860
self.assertHandlerEqual('Branch.get_config_file',
1811
smart.branch.SmartServerBranchGetConfigFile)
1861
smart_branch.SmartServerBranchGetConfigFile)
1812
1862
self.assertHandlerEqual('Branch.get_parent',
1813
smart.branch.SmartServerBranchGetParent)
1863
smart_branch.SmartServerBranchGetParent)
1814
1864
self.assertHandlerEqual('Branch.get_tags_bytes',
1815
smart.branch.SmartServerBranchGetTagsBytes)
1865
smart_branch.SmartServerBranchGetTagsBytes)
1816
1866
self.assertHandlerEqual('Branch.lock_write',
1817
smart.branch.SmartServerBranchRequestLockWrite)
1867
smart_branch.SmartServerBranchRequestLockWrite)
1818
1868
self.assertHandlerEqual('Branch.last_revision_info',
1819
smart.branch.SmartServerBranchRequestLastRevisionInfo)
1869
smart_branch.SmartServerBranchRequestLastRevisionInfo)
1820
1870
self.assertHandlerEqual('Branch.revision_history',
1821
smart.branch.SmartServerRequestRevisionHistory)
1871
smart_branch.SmartServerRequestRevisionHistory)
1822
1872
self.assertHandlerEqual('Branch.set_config_option',
1823
smart.branch.SmartServerBranchRequestSetConfigOption)
1873
smart_branch.SmartServerBranchRequestSetConfigOption)
1824
1874
self.assertHandlerEqual('Branch.set_last_revision',
1825
smart.branch.SmartServerBranchRequestSetLastRevision)
1875
smart_branch.SmartServerBranchRequestSetLastRevision)
1826
1876
self.assertHandlerEqual('Branch.set_last_revision_info',
1827
smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
1877
smart_branch.SmartServerBranchRequestSetLastRevisionInfo)
1828
1878
self.assertHandlerEqual('Branch.set_last_revision_ex',
1829
smart.branch.SmartServerBranchRequestSetLastRevisionEx)
1879
smart_branch.SmartServerBranchRequestSetLastRevisionEx)
1830
1880
self.assertHandlerEqual('Branch.set_parent_location',
1831
smart.branch.SmartServerBranchRequestSetParentLocation)
1881
smart_branch.SmartServerBranchRequestSetParentLocation)
1832
1882
self.assertHandlerEqual('Branch.unlock',
1833
smart.branch.SmartServerBranchRequestUnlock)
1883
smart_branch.SmartServerBranchRequestUnlock)
1834
1884
self.assertHandlerEqual('BzrDir.find_repository',
1835
smart.bzrdir.SmartServerRequestFindRepositoryV1)
1885
smart_dir.SmartServerRequestFindRepositoryV1)
1836
1886
self.assertHandlerEqual('BzrDir.find_repositoryV2',
1837
smart.bzrdir.SmartServerRequestFindRepositoryV2)
1887
smart_dir.SmartServerRequestFindRepositoryV2)
1838
1888
self.assertHandlerEqual('BzrDirFormat.initialize',
1839
smart.bzrdir.SmartServerRequestInitializeBzrDir)
1889
smart_dir.SmartServerRequestInitializeBzrDir)
1840
1890
self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
1841
smart.bzrdir.SmartServerRequestBzrDirInitializeEx)
1891
smart_dir.SmartServerRequestBzrDirInitializeEx)
1842
1892
self.assertHandlerEqual('BzrDir.cloning_metadir',
1843
smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
1893
smart_dir.SmartServerBzrDirRequestCloningMetaDir)
1844
1894
self.assertHandlerEqual('BzrDir.get_config_file',
1845
smart.bzrdir.SmartServerBzrDirRequestConfigFile)
1895
smart_dir.SmartServerBzrDirRequestConfigFile)
1846
1896
self.assertHandlerEqual('BzrDir.open_branch',
1847
smart.bzrdir.SmartServerRequestOpenBranch)
1897
smart_dir.SmartServerRequestOpenBranch)
1848
1898
self.assertHandlerEqual('BzrDir.open_branchV2',
1849
smart.bzrdir.SmartServerRequestOpenBranchV2)
1899
smart_dir.SmartServerRequestOpenBranchV2)
1850
1900
self.assertHandlerEqual('BzrDir.open_branchV3',
1851
smart.bzrdir.SmartServerRequestOpenBranchV3)
1901
smart_dir.SmartServerRequestOpenBranchV3)
1852
1902
self.assertHandlerEqual('PackRepository.autopack',
1853
smart.packrepository.SmartServerPackRepositoryAutopack)
1903
smart_packrepo.SmartServerPackRepositoryAutopack)
1854
1904
self.assertHandlerEqual('Repository.gather_stats',
1855
smart.repository.SmartServerRepositoryGatherStats)
1905
smart_repo.SmartServerRepositoryGatherStats)
1856
1906
self.assertHandlerEqual('Repository.get_parent_map',
1857
smart.repository.SmartServerRepositoryGetParentMap)
1907
smart_repo.SmartServerRepositoryGetParentMap)
1858
1908
self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1859
smart.repository.SmartServerRepositoryGetRevIdForRevno)
1909
smart_repo.SmartServerRepositoryGetRevIdForRevno)
1860
1910
self.assertHandlerEqual('Repository.get_revision_graph',
1861
smart.repository.SmartServerRepositoryGetRevisionGraph)
1911
smart_repo.SmartServerRepositoryGetRevisionGraph)
1862
1912
self.assertHandlerEqual('Repository.get_stream',
1863
smart.repository.SmartServerRepositoryGetStream)
1913
smart_repo.SmartServerRepositoryGetStream)
1864
1914
self.assertHandlerEqual('Repository.has_revision',
1865
smart.repository.SmartServerRequestHasRevision)
1915
smart_repo.SmartServerRequestHasRevision)
1866
1916
self.assertHandlerEqual('Repository.insert_stream',
1867
smart.repository.SmartServerRepositoryInsertStream)
1917
smart_repo.SmartServerRepositoryInsertStream)
1868
1918
self.assertHandlerEqual('Repository.insert_stream_locked',
1869
smart.repository.SmartServerRepositoryInsertStreamLocked)
1919
smart_repo.SmartServerRepositoryInsertStreamLocked)
1870
1920
self.assertHandlerEqual('Repository.is_shared',
1871
smart.repository.SmartServerRepositoryIsShared)
1921
smart_repo.SmartServerRepositoryIsShared)
1872
1922
self.assertHandlerEqual('Repository.lock_write',
1873
smart.repository.SmartServerRepositoryLockWrite)
1923
smart_repo.SmartServerRepositoryLockWrite)
1874
1924
self.assertHandlerEqual('Repository.tarball',
1875
smart.repository.SmartServerRepositoryTarball)
1925
smart_repo.SmartServerRepositoryTarball)
1876
1926
self.assertHandlerEqual('Repository.unlock',
1877
smart.repository.SmartServerRepositoryUnlock)
1927
smart_repo.SmartServerRepositoryUnlock)
1878
1928
self.assertHandlerEqual('Transport.is_readonly',
1879
smart.request.SmartServerIsReadonly)
1929
smart_req.SmartServerIsReadonly)