/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Robert Collins
  • Date: 2009-05-23 20:57:12 UTC
  • mfrom: (4371 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4441.
  • Revision ID: robertc@robertcollins.net-20090523205712-lcwbfqk6vwavinuv
Merge .dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the smart wire/domain protocol.
18
18
 
177
177
        self.assertEqual(expected, request.execute('', 'False'))
178
178
 
179
179
    def test_cloning_metadir_reference(self):
180
 
        """The request works when bzrdir contains a branch reference."""
 
180
        """The request fails when bzrdir contains a branch reference."""
181
181
        backing = self.get_transport()
182
182
        referenced_branch = self.make_branch('referenced')
183
183
        dir = self.make_bzrdir('.')
189
189
        backing.rename('referenced', 'moved')
190
190
        request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
191
191
        request = request_class(backing)
192
 
        expected = SuccessfulSmartServerResponse(
193
 
            (local_result.network_name(),
194
 
            local_result.repository_format.network_name(),
195
 
            ('ref', reference_url)))
 
192
        expected = FailedSmartServerResponse(('BranchReference',))
196
193
        self.assertEqual(expected, request.execute('', 'False'))
197
194
 
198
195
 
299
296
        self.assertEqual(result, request.execute(''))
300
297
 
301
298
 
 
299
class TestSmartServerBzrDirRequestGetConfigFile(
 
300
    tests.TestCaseWithMemoryTransport):
 
301
    """Tests for BzrDir.get_config_file."""
 
302
 
 
303
    def test_present(self):
 
304
        backing = self.get_transport()
 
305
        dir = self.make_bzrdir('.')
 
306
        dir.get_config().set_default_stack_on("/")
 
307
        local_result = dir._get_config()._get_config_file().read()
 
308
        request_class = smart_dir.SmartServerBzrDirRequestConfigFile
 
309
        request = request_class(backing)
 
310
        expected = SuccessfulSmartServerResponse((), local_result)
 
311
        self.assertEqual(expected, request.execute(''))
 
312
 
 
313
    def test_missing(self):
 
314
        backing = self.get_transport()
 
315
        dir = self.make_bzrdir('.')
 
316
        request_class = smart_dir.SmartServerBzrDirRequestConfigFile
 
317
        request = request_class(backing)
 
318
        expected = SuccessfulSmartServerResponse((), '')
 
319
        self.assertEqual(expected, request.execute(''))
 
320
 
 
321
 
302
322
class TestSmartServerRequestInitializeBzrDir(tests.TestCaseWithMemoryTransport):
303
323
 
304
324
    def test_empty_dir(self):
330
350
            request.execute, 'subdir')
331
351
 
332
352
 
 
353
class TestSmartServerRequestBzrDirInitializeEx(tests.TestCaseWithMemoryTransport):
 
354
    """Basic tests for BzrDir.initialize_ex in the smart server.
 
355
 
 
356
    The main unit tests in test_bzrdir exercise the API comprehensively.
 
357
    """
 
358
 
 
359
    def test_empty_dir(self):
 
360
        """Initializing an empty dir should succeed and do it."""
 
361
        backing = self.get_transport()
 
362
        name = self.make_bzrdir('reference')._format.network_name()
 
363
        request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)
 
364
        self.assertEqual(SmartServerResponse(('', '', '', '', '', '', name,
 
365
            'False', '', '', '')),
 
366
            request.execute(name, '', 'True', 'False', 'False', '', '', '', '',
 
367
            'False'))
 
368
        made_dir = bzrdir.BzrDir.open_from_transport(backing)
 
369
        # no branch, tree or repository is expected with the current
 
370
        # default format.
 
371
        self.assertRaises(errors.NoWorkingTree, made_dir.open_workingtree)
 
372
        self.assertRaises(errors.NotBranchError, made_dir.open_branch)
 
373
        self.assertRaises(errors.NoRepositoryPresent, made_dir.open_repository)
 
374
 
 
375
    def test_missing_dir(self):
 
376
        """Initializing a missing directory should fail like the bzrdir api."""
 
377
        backing = self.get_transport()
 
378
        name = self.make_bzrdir('reference')._format.network_name()
 
379
        request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)
 
380
        self.assertRaises(errors.NoSuchFile, request.execute, name,
 
381
            'subdir/dir', 'False', 'False', 'False', '', '', '', '', 'False')
 
382
 
 
383
    def test_initialized_dir(self):
 
384
        """Initializing an extant dirctory should fail like the bzrdir api."""
 
385
        backing = self.get_transport()
 
386
        name = self.make_bzrdir('reference')._format.network_name()
 
387
        request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)
 
388
        self.make_bzrdir('subdir')
 
389
        self.assertRaises(errors.FileExists, request.execute, name, 'subdir',
 
390
            'False', 'False', 'False', '', '', '', '', 'False')
 
391
 
 
392
 
333
393
class TestSmartServerRequestOpenBranch(TestCaseWithChrootedTransport):
334
394
 
335
395
    def test_no_branch(self):
389
449
        self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
390
450
            request.execute('reference'))
391
451
 
 
452
    def test_stacked_branch(self):
 
453
        """Opening a stacked branch does not open the stacked-on branch."""
 
454
        trunk = self.make_branch('trunk')
 
455
        feature = self.make_branch('feature', format='1.9')
 
456
        feature.set_stacked_on_url(trunk.base)
 
457
        opened_branches = []
 
458
        Branch.hooks.install_named_hook('open', opened_branches.append, None)
 
459
        backing = self.get_transport()
 
460
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
461
        request.setup_jail()
 
462
        try:
 
463
            response = request.execute('feature')
 
464
        finally:
 
465
            request.teardown_jail()
 
466
        expected_format = feature._format.network_name()
 
467
        self.assertEqual(
 
468
            SuccessfulSmartServerResponse(('branch', expected_format)),
 
469
            response)
 
470
        self.assertLength(1, opened_branches)
 
471
 
392
472
 
393
473
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
394
474
 
485
565
            request.execute(''))
486
566
 
487
567
 
488
 
class SetLastRevisionTestBase(tests.TestCaseWithMemoryTransport):
 
568
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
 
569
 
 
570
    def get_lock_tokens(self, branch):
 
571
        branch_token = branch.lock_write()
 
572
        repo_token = branch.repository.lock_write()
 
573
        branch.repository.unlock()
 
574
        return branch_token, repo_token
 
575
 
 
576
 
 
577
class TestSmartServerBranchRequestSetConfigOption(TestLockedBranch):
 
578
 
 
579
    def test_value_name(self):
 
580
        branch = self.make_branch('.')
 
581
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
 
582
            branch.bzrdir.root_transport)
 
583
        branch_token, repo_token = self.get_lock_tokens(branch)
 
584
        config = branch._get_config()
 
585
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
 
586
            '')
 
587
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
 
588
        self.assertEqual('bar', config.get_option('foo'))
 
589
        # Cleanup
 
590
        branch.unlock()
 
591
 
 
592
    def test_value_name_section(self):
 
593
        branch = self.make_branch('.')
 
594
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
 
595
            branch.bzrdir.root_transport)
 
596
        branch_token, repo_token = self.get_lock_tokens(branch)
 
597
        config = branch._get_config()
 
598
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
 
599
            'gam')
 
600
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
 
601
        self.assertEqual('bar', config.get_option('foo', 'gam'))
 
602
        # Cleanup
 
603
        branch.unlock()
 
604
 
 
605
 
 
606
class SetLastRevisionTestBase(TestLockedBranch):
489
607
    """Base test case for verbs that implement set_last_revision."""
490
608
 
491
609
    def setUp(self):
495
613
        self.tree = self.make_branch_and_memory_tree('.')
496
614
 
497
615
    def lock_branch(self):
498
 
        b = self.tree.branch
499
 
        branch_token = b.lock_write()
500
 
        repo_token = b.repository.lock_write()
501
 
        b.repository.unlock()
502
 
        return branch_token, repo_token
 
616
        return self.get_lock_tokens(self.tree.branch)
503
617
 
504
618
    def unlock_branch(self):
505
619
        self.tree.branch.unlock()
722
836
            response)
723
837
 
724
838
 
 
839
class TestSmartServerBranchRequestSetParent(tests.TestCaseWithMemoryTransport):
 
840
 
 
841
    def test_set_parent_none(self):
 
842
        branch = self.make_branch('base', format="1.9")
 
843
        branch.lock_write()
 
844
        branch._set_parent_location('foo')
 
845
        branch.unlock()
 
846
        request = smart.branch.SmartServerBranchRequestSetParentLocation(
 
847
            self.get_transport())
 
848
        branch_token = branch.lock_write()
 
849
        repo_token = branch.repository.lock_write()
 
850
        try:
 
851
            response = request.execute('base', branch_token, repo_token, '')
 
852
        finally:
 
853
            branch.repository.unlock()
 
854
            branch.unlock()
 
855
        self.assertEqual(SuccessfulSmartServerResponse(()), response)
 
856
        self.assertEqual(None, branch.get_parent())
 
857
 
 
858
    def test_set_parent_something(self):
 
859
        branch = self.make_branch('base', format="1.9")
 
860
        request = smart.branch.SmartServerBranchRequestSetParentLocation(
 
861
            self.get_transport())
 
862
        branch_token = branch.lock_write()
 
863
        repo_token = branch.repository.lock_write()
 
864
        try:
 
865
            response = request.execute('base', branch_token, repo_token,
 
866
            'http://bar/')
 
867
        finally:
 
868
            branch.repository.unlock()
 
869
            branch.unlock()
 
870
        self.assertEqual(SuccessfulSmartServerResponse(()), response)
 
871
        self.assertEqual('http://bar/', branch.get_parent())
 
872
 
 
873
 
725
874
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
726
875
# Only called when the branch format and tags match [yay factory
727
876
# methods] so only need to test straight forward cases.
770
919
        # with a new branch object.
771
920
        new_branch = repository.bzrdir.open_branch()
772
921
        self.assertRaises(errors.LockContention, new_branch.lock_write)
 
922
        # Cleanup
 
923
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
 
924
        response = request.execute('', branch_nonce, repository_nonce)
773
925
 
774
926
    def test_lock_write_on_locked_branch(self):
775
927
        backing = self.get_transport()
776
928
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
777
929
        branch = self.make_branch('.')
778
 
        branch.lock_write()
 
930
        branch_token = branch.lock_write()
779
931
        branch.leave_lock_in_place()
780
932
        branch.unlock()
781
933
        response = request.execute('')
782
934
        self.assertEqual(
783
935
            SmartServerResponse(('LockContention',)), response)
 
936
        # Cleanup
 
937
        branch.lock_write(branch_token)
 
938
        branch.dont_leave_lock_in_place()
 
939
        branch.unlock()
784
940
 
785
941
    def test_lock_write_with_tokens_on_locked_branch(self):
786
942
        backing = self.get_transport()
796
952
                                   branch_token, repo_token)
797
953
        self.assertEqual(
798
954
            SmartServerResponse(('ok', branch_token, repo_token)), response)
 
955
        # Cleanup
 
956
        branch.repository.lock_write(repo_token)
 
957
        branch.repository.dont_leave_lock_in_place()
 
958
        branch.repository.unlock()
 
959
        branch.lock_write(branch_token)
 
960
        branch.dont_leave_lock_in_place()
 
961
        branch.unlock()
799
962
 
800
963
    def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
801
964
        backing = self.get_transport()
811
974
                                   branch_token+'xxx', repo_token)
812
975
        self.assertEqual(
813
976
            SmartServerResponse(('TokenMismatch',)), response)
 
977
        # Cleanup
 
978
        branch.repository.lock_write(repo_token)
 
979
        branch.repository.dont_leave_lock_in_place()
 
980
        branch.repository.unlock()
 
981
        branch.lock_write(branch_token)
 
982
        branch.dont_leave_lock_in_place()
 
983
        branch.unlock()
814
984
 
815
985
    def test_lock_write_on_locked_repo(self):
816
986
        backing = self.get_transport()
817
987
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
818
988
        branch = self.make_branch('.', format='knit')
819
 
        branch.repository.lock_write()
820
 
        branch.repository.leave_lock_in_place()
821
 
        branch.repository.unlock()
 
989
        repo = branch.repository
 
990
        repo_token = repo.lock_write()
 
991
        repo.leave_lock_in_place()
 
992
        repo.unlock()
822
993
        response = request.execute('')
823
994
        self.assertEqual(
824
995
            SmartServerResponse(('LockContention',)), response)
 
996
        # Cleanup
 
997
        repo.lock_write(repo_token)
 
998
        repo.dont_leave_lock_in_place()
 
999
        repo.unlock()
825
1000
 
826
1001
    def test_lock_write_on_readonly_transport(self):
827
1002
        backing = self.get_readonly_transport()
886
1061
            '', 'branch token', repo_token)
887
1062
        self.assertEqual(
888
1063
            SmartServerResponse(('TokenMismatch',)), response)
 
1064
        # Cleanup
 
1065
        branch.repository.lock_write(repo_token)
 
1066
        branch.repository.dont_leave_lock_in_place()
 
1067
        branch.repository.unlock()
889
1068
 
890
1069
 
891
1070
class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport):
914
1093
 
915
1094
        self.assertEqual(None,
916
1095
            request.execute('', 'missing-id'))
917
 
        # Note that it returns a body (of '' bzipped).
 
1096
        # Note that it returns a body that is bzipped.
918
1097
        self.assertEqual(
919
1098
            SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
920
1099
            request.do_body('\n\n0\n'))
921
1100
 
 
1101
    def test_trivial_include_missing(self):
 
1102
        backing = self.get_transport()
 
1103
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
 
1104
        tree = self.make_branch_and_memory_tree('.')
 
1105
 
 
1106
        self.assertEqual(None,
 
1107
            request.execute('', 'missing-id', 'include-missing:'))
 
1108
        self.assertEqual(
 
1109
            SuccessfulSmartServerResponse(('ok', ),
 
1110
                bz2.compress('missing:missing-id')),
 
1111
            request.do_body('\n\n0\n'))
 
1112
 
922
1113
 
923
1114
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
924
1115
 
1114
1305
 
1115
1306
class TestSmartServerRepositoryLockWrite(tests.TestCaseWithMemoryTransport):
1116
1307
 
1117
 
    def setUp(self):
1118
 
        tests.TestCaseWithMemoryTransport.setUp(self)
1119
 
 
1120
1308
    def test_lock_write_on_unlocked_repo(self):
1121
1309
        backing = self.get_transport()
1122
1310
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1128
1316
        # object.
1129
1317
        new_repo = repository.bzrdir.open_repository()
1130
1318
        self.assertRaises(errors.LockContention, new_repo.lock_write)
 
1319
        # Cleanup
 
1320
        request = smart.repository.SmartServerRepositoryUnlock(backing)
 
1321
        response = request.execute('', nonce)
1131
1322
 
1132
1323
    def test_lock_write_on_locked_repo(self):
1133
1324
        backing = self.get_transport()
1134
1325
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1135
1326
        repository = self.make_repository('.', format='knit')
1136
 
        repository.lock_write()
 
1327
        repo_token = repository.lock_write()
1137
1328
        repository.leave_lock_in_place()
1138
1329
        repository.unlock()
1139
1330
        response = request.execute('')
1140
1331
        self.assertEqual(
1141
1332
            SmartServerResponse(('LockContention',)), response)
 
1333
        # Cleanup
 
1334
        repository.lock_write(repo_token)
 
1335
        repository.dont_leave_lock_in_place()
 
1336
        repository.unlock()
1142
1337
 
1143
1338
    def test_lock_write_on_readonly_transport(self):
1144
1339
        backing = self.get_readonly_transport()
1149
1344
        self.assertEqual('LockFailed', response.args[0])
1150
1345
 
1151
1346
 
 
1347
class TestInsertStreamBase(tests.TestCaseWithMemoryTransport):
 
1348
 
 
1349
    def make_empty_byte_stream(self, repo):
 
1350
        byte_stream = smart.repository._stream_to_byte_stream([], repo._format)
 
1351
        return ''.join(byte_stream)
 
1352
 
 
1353
 
 
1354
class TestSmartServerRepositoryInsertStream(TestInsertStreamBase):
 
1355
 
 
1356
    def test_insert_stream_empty(self):
 
1357
        backing = self.get_transport()
 
1358
        request = smart.repository.SmartServerRepositoryInsertStream(backing)
 
1359
        repository = self.make_repository('.')
 
1360
        response = request.execute('', '')
 
1361
        self.assertEqual(None, response)
 
1362
        response = request.do_chunk(self.make_empty_byte_stream(repository))
 
1363
        self.assertEqual(None, response)
 
1364
        response = request.do_end()
 
1365
        self.assertEqual(SmartServerResponse(('ok', )), response)
 
1366
        
 
1367
 
 
1368
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
 
1369
 
 
1370
    def test_insert_stream_empty(self):
 
1371
        backing = self.get_transport()
 
1372
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
 
1373
            backing)
 
1374
        repository = self.make_repository('.', format='knit')
 
1375
        lock_token = repository.lock_write()
 
1376
        response = request.execute('', '', lock_token)
 
1377
        self.assertEqual(None, response)
 
1378
        response = request.do_chunk(self.make_empty_byte_stream(repository))
 
1379
        self.assertEqual(None, response)
 
1380
        response = request.do_end()
 
1381
        self.assertEqual(SmartServerResponse(('ok', )), response)
 
1382
        repository.unlock()
 
1383
 
 
1384
    def test_insert_stream_with_wrong_lock_token(self):
 
1385
        backing = self.get_transport()
 
1386
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
 
1387
            backing)
 
1388
        repository = self.make_repository('.', format='knit')
 
1389
        lock_token = repository.lock_write()
 
1390
        self.assertRaises(
 
1391
            errors.TokenMismatch, request.execute, '', '', 'wrong-token')
 
1392
        repository.unlock()
 
1393
 
 
1394
 
1152
1395
class TestSmartServerRepositoryUnlock(tests.TestCaseWithMemoryTransport):
1153
1396
 
1154
1397
    def setUp(self):
1237
1480
 
1238
1481
    def test_autopack_needed(self):
1239
1482
        repo = self.make_repo_needing_autopacking()
 
1483
        repo.lock_write()
 
1484
        self.addCleanup(repo.unlock)
1240
1485
        backing = self.get_transport()
1241
1486
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1242
1487
            backing)
1248
1493
    def test_autopack_not_needed(self):
1249
1494
        tree = self.make_branch_and_tree('.', format='pack-0.92')
1250
1495
        repo = tree.branch.repository
 
1496
        repo.lock_write()
 
1497
        self.addCleanup(repo.unlock)
1251
1498
        for x in range(9):
1252
1499
            tree.commit('commit %s' % x)
1253
1500
        backing = self.get_transport()
1278
1525
        for key, item in smart.request.request_handlers.iteritems():
1279
1526
            pass
1280
1527
 
 
1528
    def assertHandlerEqual(self, verb, handler):
 
1529
        self.assertEqual(smart.request.request_handlers.get(verb), handler)
 
1530
 
1281
1531
    def test_registered_methods(self):
1282
1532
        """Test that known methods are registered to the correct object."""
1283
 
        self.assertEqual(
1284
 
            smart.request.request_handlers.get('Branch.get_config_file'),
 
1533
        self.assertHandlerEqual('Branch.get_config_file',
1285
1534
            smart.branch.SmartServerBranchGetConfigFile)
1286
 
        self.assertEqual(
1287
 
            smart.request.request_handlers.get('Branch.get_parent'),
 
1535
        self.assertHandlerEqual('Branch.get_parent',
1288
1536
            smart.branch.SmartServerBranchGetParent)
1289
 
        self.assertEqual(
1290
 
            smart.request.request_handlers.get('Branch.get_tags_bytes'),
 
1537
        self.assertHandlerEqual('Branch.get_tags_bytes',
1291
1538
            smart.branch.SmartServerBranchGetTagsBytes)
1292
 
        self.assertEqual(
1293
 
            smart.request.request_handlers.get('Branch.lock_write'),
 
1539
        self.assertHandlerEqual('Branch.lock_write',
1294
1540
            smart.branch.SmartServerBranchRequestLockWrite)
1295
 
        self.assertEqual(
1296
 
            smart.request.request_handlers.get('Branch.last_revision_info'),
 
1541
        self.assertHandlerEqual('Branch.last_revision_info',
1297
1542
            smart.branch.SmartServerBranchRequestLastRevisionInfo)
1298
 
        self.assertEqual(
1299
 
            smart.request.request_handlers.get('Branch.revision_history'),
 
1543
        self.assertHandlerEqual('Branch.revision_history',
1300
1544
            smart.branch.SmartServerRequestRevisionHistory)
1301
 
        self.assertEqual(
1302
 
            smart.request.request_handlers.get('Branch.set_last_revision'),
 
1545
        self.assertHandlerEqual('Branch.set_config_option',
 
1546
            smart.branch.SmartServerBranchRequestSetConfigOption)
 
1547
        self.assertHandlerEqual('Branch.set_last_revision',
1303
1548
            smart.branch.SmartServerBranchRequestSetLastRevision)
1304
 
        self.assertEqual(
1305
 
            smart.request.request_handlers.get('Branch.set_last_revision_info'),
 
1549
        self.assertHandlerEqual('Branch.set_last_revision_info',
1306
1550
            smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
1307
 
        self.assertEqual(
1308
 
            smart.request.request_handlers.get('Branch.unlock'),
 
1551
        self.assertHandlerEqual('Branch.set_last_revision_ex',
 
1552
            smart.branch.SmartServerBranchRequestSetLastRevisionEx)
 
1553
        self.assertHandlerEqual('Branch.set_parent_location',
 
1554
            smart.branch.SmartServerBranchRequestSetParentLocation)
 
1555
        self.assertHandlerEqual('Branch.unlock',
1309
1556
            smart.branch.SmartServerBranchRequestUnlock)
1310
 
        self.assertEqual(
1311
 
            smart.request.request_handlers.get('BzrDir.find_repository'),
 
1557
        self.assertHandlerEqual('BzrDir.find_repository',
1312
1558
            smart.bzrdir.SmartServerRequestFindRepositoryV1)
1313
 
        self.assertEqual(
1314
 
            smart.request.request_handlers.get('BzrDir.find_repositoryV2'),
 
1559
        self.assertHandlerEqual('BzrDir.find_repositoryV2',
1315
1560
            smart.bzrdir.SmartServerRequestFindRepositoryV2)
1316
 
        self.assertEqual(
1317
 
            smart.request.request_handlers.get('BzrDirFormat.initialize'),
 
1561
        self.assertHandlerEqual('BzrDirFormat.initialize',
1318
1562
            smart.bzrdir.SmartServerRequestInitializeBzrDir)
1319
 
        self.assertEqual(
1320
 
            smart.request.request_handlers.get('BzrDir.cloning_metadir'),
 
1563
        self.assertHandlerEqual('BzrDirFormat.initialize_ex',
 
1564
            smart.bzrdir.SmartServerRequestBzrDirInitializeEx)
 
1565
        self.assertHandlerEqual('BzrDir.cloning_metadir',
1321
1566
            smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
1322
 
        self.assertEqual(
1323
 
            smart.request.request_handlers.get('BzrDir.open_branch'),
 
1567
        self.assertHandlerEqual('BzrDir.get_config_file',
 
1568
            smart.bzrdir.SmartServerBzrDirRequestConfigFile)
 
1569
        self.assertHandlerEqual('BzrDir.open_branch',
1324
1570
            smart.bzrdir.SmartServerRequestOpenBranch)
1325
 
        self.assertEqual(
1326
 
            smart.request.request_handlers.get('BzrDir.open_branchV2'),
 
1571
        self.assertHandlerEqual('BzrDir.open_branchV2',
1327
1572
            smart.bzrdir.SmartServerRequestOpenBranchV2)
1328
 
        self.assertEqual(
1329
 
            smart.request.request_handlers.get('PackRepository.autopack'),
 
1573
        self.assertHandlerEqual('PackRepository.autopack',
1330
1574
            smart.packrepository.SmartServerPackRepositoryAutopack)
1331
 
        self.assertEqual(
1332
 
            smart.request.request_handlers.get('Repository.gather_stats'),
 
1575
        self.assertHandlerEqual('Repository.gather_stats',
1333
1576
            smart.repository.SmartServerRepositoryGatherStats)
1334
 
        self.assertEqual(
1335
 
            smart.request.request_handlers.get('Repository.get_parent_map'),
 
1577
        self.assertHandlerEqual('Repository.get_parent_map',
1336
1578
            smart.repository.SmartServerRepositoryGetParentMap)
1337
 
        self.assertEqual(
1338
 
            smart.request.request_handlers.get(
1339
 
                'Repository.get_revision_graph'),
 
1579
        self.assertHandlerEqual('Repository.get_revision_graph',
1340
1580
            smart.repository.SmartServerRepositoryGetRevisionGraph)
1341
 
        self.assertEqual(
1342
 
            smart.request.request_handlers.get('Repository.has_revision'),
 
1581
        self.assertHandlerEqual('Repository.get_stream',
 
1582
            smart.repository.SmartServerRepositoryGetStream)
 
1583
        self.assertHandlerEqual('Repository.has_revision',
1343
1584
            smart.repository.SmartServerRequestHasRevision)
1344
 
        self.assertEqual(
1345
 
            smart.request.request_handlers.get('Repository.is_shared'),
 
1585
        self.assertHandlerEqual('Repository.insert_stream',
 
1586
            smart.repository.SmartServerRepositoryInsertStream)
 
1587
        self.assertHandlerEqual('Repository.insert_stream_locked',
 
1588
            smart.repository.SmartServerRepositoryInsertStreamLocked)
 
1589
        self.assertHandlerEqual('Repository.is_shared',
1346
1590
            smart.repository.SmartServerRepositoryIsShared)
1347
 
        self.assertEqual(
1348
 
            smart.request.request_handlers.get('Repository.lock_write'),
 
1591
        self.assertHandlerEqual('Repository.lock_write',
1349
1592
            smart.repository.SmartServerRepositoryLockWrite)
1350
 
        self.assertEqual(
1351
 
            smart.request.request_handlers.get('Repository.get_stream'),
1352
 
            smart.repository.SmartServerRepositoryGetStream)
1353
 
        self.assertEqual(
1354
 
            smart.request.request_handlers.get('Repository.tarball'),
 
1593
        self.assertHandlerEqual('Repository.tarball',
1355
1594
            smart.repository.SmartServerRepositoryTarball)
1356
 
        self.assertEqual(
1357
 
            smart.request.request_handlers.get('Repository.unlock'),
 
1595
        self.assertHandlerEqual('Repository.unlock',
1358
1596
            smart.repository.SmartServerRepositoryUnlock)
1359
 
        self.assertEqual(
1360
 
            smart.request.request_handlers.get('Transport.is_readonly'),
 
1597
        self.assertHandlerEqual('Transport.is_readonly',
1361
1598
            smart.request.SmartServerIsReadonly)