/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: Jelmer Vernooij
  • Date: 2011-12-14 12:25:34 UTC
  • mto: (6282.6.42 hpss-get-inventories)
  • mto: This revision was merged to the branch mainline in revision 6371.
  • Revision ID: jelmer@samba.org-20111214122534-5ot01rv7miypacmf
More documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
25
25
"""
26
26
 
27
27
import bz2
28
 
from cStringIO import StringIO
29
 
import tarfile
 
28
import zlib
30
29
 
31
30
from bzrlib import (
32
 
    bencode,
33
31
    branch as _mod_branch,
34
32
    bzrdir,
35
33
    errors,
36
 
    pack,
 
34
    gpg,
37
35
    tests,
38
36
    transport,
39
37
    urlutils,
48
46
    server,
49
47
    vfs,
50
48
    )
 
49
from bzrlib.testament import Testament
51
50
from bzrlib.tests import test_server
52
51
from bzrlib.transport import (
53
52
    chroot,
89
88
            backing_transport = tests.TestCaseWithTransport.get_transport(self)
90
89
            self._chroot_server = chroot.ChrootServer(backing_transport)
91
90
            self.start_server(self._chroot_server)
92
 
        t = transport.get_transport(self._chroot_server.get_url())
 
91
        t = transport.get_transport_from_url(self._chroot_server.get_url())
93
92
        if relpath is not None:
94
93
            t = t.clone(relpath)
95
94
        return t
103
102
        # the default or a parameterized class, but rather use the
104
103
        # TestCaseWithTransport infrastructure to set up a smart server and
105
104
        # transport.
106
 
        self.transport_server = self.make_transport_server
 
105
        self.overrideAttr(self, "transport_server", self.make_transport_server)
107
106
 
108
107
    def make_transport_server(self):
109
108
        return test_server.SmartTCPServer_for_testing('-' + self.id())
225
224
        self.assertEqual(expected, request.execute('', 'False'))
226
225
 
227
226
 
 
227
class TestSmartServerBzrDirRequestCloningMetaDir(
 
228
    tests.TestCaseWithMemoryTransport):
 
229
    """Tests for BzrDir.checkout_metadir."""
 
230
 
 
231
    def test_checkout_metadir(self):
 
232
        backing = self.get_transport()
 
233
        request = smart_dir.SmartServerBzrDirRequestCheckoutMetaDir(
 
234
            backing)
 
235
        branch = self.make_branch('.', format='2a')
 
236
        response = request.execute('')
 
237
        self.assertEqual(
 
238
            smart_req.SmartServerResponse(
 
239
                ('Bazaar-NG meta directory, format 1\n',
 
240
                 'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
 
241
                 'Bazaar Branch Format 7 (needs bzr 1.6)\n')),
 
242
            response)
 
243
 
 
244
 
 
245
class TestSmartServerBzrDirRequestDestroyBranch(
 
246
    tests.TestCaseWithMemoryTransport):
 
247
    """Tests for BzrDir.destroy_branch."""
 
248
 
 
249
    def test_destroy_branch_default(self):
 
250
        """The default branch can be removed."""
 
251
        backing = self.get_transport()
 
252
        dir = self.make_branch('.').bzrdir
 
253
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
 
254
        request = request_class(backing)
 
255
        expected = smart_req.SuccessfulSmartServerResponse(('ok',))
 
256
        self.assertEqual(expected, request.execute('', None))
 
257
 
 
258
    def test_destroy_branch_named(self):
 
259
        """A named branch can be removed."""
 
260
        backing = self.get_transport()
 
261
        dir = self.make_repository('.', format="development-colo").bzrdir
 
262
        dir.create_branch(name="branchname")
 
263
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
 
264
        request = request_class(backing)
 
265
        expected = smart_req.SuccessfulSmartServerResponse(('ok',))
 
266
        self.assertEqual(expected, request.execute('', "branchname"))
 
267
 
 
268
    def test_destroy_branch_missing(self):
 
269
        """An error is raised if the branch didn't exist."""
 
270
        backing = self.get_transport()
 
271
        dir = self.make_bzrdir('.', format="development-colo")
 
272
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
 
273
        request = request_class(backing)
 
274
        expected = smart_req.FailedSmartServerResponse(('nobranch',), None)
 
275
        self.assertEqual(expected, request.execute('', "branchname"))
 
276
 
 
277
 
 
278
class TestSmartServerBzrDirRequestHasWorkingTree(
 
279
    tests.TestCaseWithTransport):
 
280
    """Tests for BzrDir.has_workingtree."""
 
281
 
 
282
    def test_has_workingtree_yes(self):
 
283
        """A working tree is present."""
 
284
        backing = self.get_transport()
 
285
        dir = self.make_branch_and_tree('.').bzrdir
 
286
        request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
 
287
        request = request_class(backing)
 
288
        expected = smart_req.SuccessfulSmartServerResponse(('yes',))
 
289
        self.assertEqual(expected, request.execute(''))
 
290
 
 
291
    def test_has_workingtree_no(self):
 
292
        """A working tree is missing."""
 
293
        backing = self.get_transport()
 
294
        dir = self.make_bzrdir('.')
 
295
        request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
 
296
        request = request_class(backing)
 
297
        expected = smart_req.SuccessfulSmartServerResponse(('no',))
 
298
        self.assertEqual(expected, request.execute(''))
 
299
 
 
300
 
 
301
class TestSmartServerBzrDirRequestDestroyRepository(
 
302
    tests.TestCaseWithMemoryTransport):
 
303
    """Tests for BzrDir.destroy_repository."""
 
304
 
 
305
    def test_destroy_repository_default(self):
 
306
        """The repository can be removed."""
 
307
        backing = self.get_transport()
 
308
        dir = self.make_repository('.').bzrdir
 
309
        request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
 
310
        request = request_class(backing)
 
311
        expected = smart_req.SuccessfulSmartServerResponse(('ok',))
 
312
        self.assertEqual(expected, request.execute(''))
 
313
 
 
314
    def test_destroy_repository_missing(self):
 
315
        """An error is raised if the repository didn't exist."""
 
316
        backing = self.get_transport()
 
317
        dir = self.make_bzrdir('.')
 
318
        request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
 
319
        request = request_class(backing)
 
320
        expected = smart_req.FailedSmartServerResponse(
 
321
            ('norepository',), None)
 
322
        self.assertEqual(expected, request.execute(''))
 
323
 
 
324
 
228
325
class TestSmartServerRequestCreateRepository(tests.TestCaseWithMemoryTransport):
229
326
    """Tests for BzrDir.create_repository."""
230
327
 
739
836
            request.execute(''))
740
837
 
741
838
 
 
839
class TestSmartServerBranchRequestRevisionIdToRevno(
 
840
    tests.TestCaseWithMemoryTransport):
 
841
 
 
842
    def test_null(self):
 
843
        backing = self.get_transport()
 
844
        request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
 
845
            backing)
 
846
        self.make_branch('.')
 
847
        self.assertEqual(smart_req.SmartServerResponse(('ok', '0')),
 
848
            request.execute('', 'null:'))
 
849
 
 
850
    def test_simple(self):
 
851
        backing = self.get_transport()
 
852
        request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
 
853
            backing)
 
854
        tree = self.make_branch_and_memory_tree('.')
 
855
        tree.lock_write()
 
856
        tree.add('')
 
857
        r1 = tree.commit('1st commit')
 
858
        tree.unlock()
 
859
        self.assertEqual(
 
860
            smart_req.SmartServerResponse(('ok', '1')),
 
861
            request.execute('', r1))
 
862
 
 
863
    def test_not_found(self):
 
864
        backing = self.get_transport()
 
865
        request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
 
866
            backing)
 
867
        branch = self.make_branch('.')
 
868
        self.assertEqual(
 
869
            smart_req.FailedSmartServerResponse(
 
870
                ('NoSuchRevision', 'idontexist')),
 
871
            request.execute('', 'idontexist'))
 
872
 
 
873
 
742
874
class TestSmartServerBranchRequestGetConfigFile(
743
875
    tests.TestCaseWithMemoryTransport):
744
876
 
767
899
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
768
900
 
769
901
    def get_lock_tokens(self, branch):
770
 
        branch_token = branch.lock_write()
771
 
        repo_token = branch.repository.lock_write()
 
902
        branch_token = branch.lock_write().branch_token
 
903
        repo_token = branch.repository.lock_write().repository_token
772
904
        branch.repository.unlock()
773
905
        return branch_token, repo_token
774
906
 
775
907
 
 
908
class TestSmartServerBranchRequestPutConfigFile(TestLockedBranch):
 
909
 
 
910
    def test_with_content(self):
 
911
        backing = self.get_transport()
 
912
        request = smart_branch.SmartServerBranchPutConfigFile(backing)
 
913
        branch = self.make_branch('.')
 
914
        branch_token, repo_token = self.get_lock_tokens(branch)
 
915
        self.assertIs(None, request.execute('', branch_token, repo_token))
 
916
        self.assertEqual(
 
917
            smart_req.SmartServerResponse(('ok', )),
 
918
            request.do_body('foo bar baz'))
 
919
        self.assertEquals(
 
920
            branch.control_transport.get_bytes('branch.conf'),
 
921
            'foo bar baz')
 
922
        branch.unlock()
 
923
 
 
924
 
776
925
class TestSmartServerBranchRequestSetConfigOption(TestLockedBranch):
777
926
 
778
927
    def test_value_name(self):
802
951
        branch.unlock()
803
952
 
804
953
 
 
954
class TestSmartServerBranchRequestSetConfigOptionDict(TestLockedBranch):
 
955
 
 
956
    def setUp(self):
 
957
        TestLockedBranch.setUp(self)
 
958
        # A dict with non-ascii keys and values to exercise unicode
 
959
        # roundtripping.
 
960
        self.encoded_value_dict = (
 
961
            'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde')
 
962
        self.value_dict = {
 
963
            'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
 
964
 
 
965
    def test_value_name(self):
 
966
        branch = self.make_branch('.')
 
967
        request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
 
968
            branch.bzrdir.root_transport)
 
969
        branch_token, repo_token = self.get_lock_tokens(branch)
 
970
        config = branch._get_config()
 
971
        result = request.execute('', branch_token, repo_token,
 
972
            self.encoded_value_dict, 'foo', '')
 
973
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
974
        self.assertEqual(self.value_dict, config.get_option('foo'))
 
975
        # Cleanup
 
976
        branch.unlock()
 
977
 
 
978
    def test_value_name_section(self):
 
979
        branch = self.make_branch('.')
 
980
        request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
 
981
            branch.bzrdir.root_transport)
 
982
        branch_token, repo_token = self.get_lock_tokens(branch)
 
983
        config = branch._get_config()
 
984
        result = request.execute('', branch_token, repo_token,
 
985
            self.encoded_value_dict, 'foo', 'gam')
 
986
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
987
        self.assertEqual(self.value_dict, config.get_option('foo', 'gam'))
 
988
        # Cleanup
 
989
        branch.unlock()
 
990
 
 
991
 
805
992
class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):
806
993
    # Only called when the branch format and tags match [yay factory
807
994
    # methods] so only need to test straight forward cases.
898
1085
        # its repository.
899
1086
        self.make_tree_with_two_commits()
900
1087
        rev_id_utf8 = u'\xc8'.encode('utf-8')
901
 
        self.tree.branch.set_revision_history([])
 
1088
        self.tree.branch.set_last_revision_info(0, 'null:')
902
1089
        self.assertEqual(
903
1090
            (0, 'null:'), self.tree.branch.last_revision_info())
904
1091
        # We can update the branch to a revision that is present in the
1054
1241
        self.assertEqual('child-1', self.tree.branch.last_revision())
1055
1242
 
1056
1243
 
 
1244
class TestSmartServerBranchBreakLock(tests.TestCaseWithMemoryTransport):
 
1245
 
 
1246
    def test_lock_to_break(self):
 
1247
        base_branch = self.make_branch('base')
 
1248
        request = smart_branch.SmartServerBranchBreakLock(
 
1249
            self.get_transport())
 
1250
        base_branch.lock_write()
 
1251
        self.assertEqual(
 
1252
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1253
            request.execute('base'))
 
1254
 
 
1255
    def test_nothing_to_break(self):
 
1256
        base_branch = self.make_branch('base')
 
1257
        request = smart_branch.SmartServerBranchBreakLock(
 
1258
            self.get_transport())
 
1259
        self.assertEqual(
 
1260
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1261
            request.execute('base'))
 
1262
 
 
1263
 
1057
1264
class TestSmartServerBranchRequestGetParent(tests.TestCaseWithMemoryTransport):
1058
1265
 
1059
1266
    def test_get_parent_none(self):
1073
1280
            response)
1074
1281
 
1075
1282
 
1076
 
class TestSmartServerBranchRequestSetParent(tests.TestCaseWithMemoryTransport):
 
1283
class TestSmartServerBranchRequestSetParent(TestLockedBranch):
1077
1284
 
1078
1285
    def test_set_parent_none(self):
1079
1286
        branch = self.make_branch('base', format="1.9")
1082
1289
        branch.unlock()
1083
1290
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
1084
1291
            self.get_transport())
1085
 
        branch_token = branch.lock_write()
1086
 
        repo_token = branch.repository.lock_write()
 
1292
        branch_token, repo_token = self.get_lock_tokens(branch)
1087
1293
        try:
1088
1294
            response = request.execute('base', branch_token, repo_token, '')
1089
1295
        finally:
1090
 
            branch.repository.unlock()
1091
1296
            branch.unlock()
1092
1297
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1093
1298
        self.assertEqual(None, branch.get_parent())
1096
1301
        branch = self.make_branch('base', format="1.9")
1097
1302
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
1098
1303
            self.get_transport())
1099
 
        branch_token = branch.lock_write()
1100
 
        repo_token = branch.repository.lock_write()
 
1304
        branch_token, repo_token = self.get_lock_tokens(branch)
1101
1305
        try:
1102
1306
            response = request.execute('base', branch_token, repo_token,
1103
1307
            'http://bar/')
1104
1308
        finally:
1105
 
            branch.repository.unlock()
1106
1309
            branch.unlock()
1107
1310
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1108
1311
        self.assertEqual('http://bar/', branch.get_parent())
1137
1340
            response)
1138
1341
 
1139
1342
 
1140
 
class TestSmartServerBranchRequestLockWrite(tests.TestCaseWithMemoryTransport):
 
1343
class TestSmartServerBranchRequestLockWrite(TestLockedBranch):
1141
1344
 
1142
1345
    def setUp(self):
1143
1346
        tests.TestCaseWithMemoryTransport.setUp(self)
1165
1368
        backing = self.get_transport()
1166
1369
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1167
1370
        branch = self.make_branch('.')
1168
 
        branch_token = branch.lock_write()
 
1371
        branch_token = branch.lock_write().branch_token
1169
1372
        branch.leave_lock_in_place()
1170
1373
        branch.unlock()
1171
1374
        response = request.execute('')
1180
1383
        backing = self.get_transport()
1181
1384
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1182
1385
        branch = self.make_branch('.', format='knit')
1183
 
        branch_token = branch.lock_write()
1184
 
        repo_token = branch.repository.lock_write()
1185
 
        branch.repository.unlock()
 
1386
        branch_token, repo_token = self.get_lock_tokens(branch)
1186
1387
        branch.leave_lock_in_place()
1187
1388
        branch.repository.leave_lock_in_place()
1188
1389
        branch.unlock()
1203
1404
        backing = self.get_transport()
1204
1405
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1205
1406
        branch = self.make_branch('.', format='knit')
1206
 
        branch_token = branch.lock_write()
1207
 
        repo_token = branch.repository.lock_write()
1208
 
        branch.repository.unlock()
 
1407
        branch_token, repo_token = self.get_lock_tokens(branch)
1209
1408
        branch.leave_lock_in_place()
1210
1409
        branch.repository.leave_lock_in_place()
1211
1410
        branch.unlock()
1226
1425
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1227
1426
        branch = self.make_branch('.', format='knit')
1228
1427
        repo = branch.repository
1229
 
        repo_token = repo.lock_write()
 
1428
        repo_token = repo.lock_write().repository_token
1230
1429
        repo.leave_lock_in_place()
1231
1430
        repo.unlock()
1232
1431
        response = request.execute('')
1249
1448
        self.assertEqual('LockFailed', error_name)
1250
1449
 
1251
1450
 
1252
 
class TestSmartServerBranchRequestUnlock(tests.TestCaseWithMemoryTransport):
 
1451
class TestSmartServerBranchRequestGetPhysicalLockStatus(TestLockedBranch):
 
1452
 
 
1453
    def setUp(self):
 
1454
        tests.TestCaseWithMemoryTransport.setUp(self)
 
1455
 
 
1456
    def test_true(self):
 
1457
        backing = self.get_transport()
 
1458
        request = smart_branch.SmartServerBranchRequestGetPhysicalLockStatus(
 
1459
            backing)
 
1460
        branch = self.make_branch('.')
 
1461
        branch_token, repo_token = self.get_lock_tokens(branch)
 
1462
        self.assertEquals(True, branch.get_physical_lock_status())
 
1463
        response = request.execute('')
 
1464
        self.assertEqual(
 
1465
            smart_req.SmartServerResponse(('yes',)), response)
 
1466
        branch.unlock()
 
1467
 
 
1468
    def test_false(self):
 
1469
        backing = self.get_transport()
 
1470
        request = smart_branch.SmartServerBranchRequestGetPhysicalLockStatus(
 
1471
            backing)
 
1472
        branch = self.make_branch('.')
 
1473
        self.assertEquals(False, branch.get_physical_lock_status())
 
1474
        response = request.execute('')
 
1475
        self.assertEqual(
 
1476
            smart_req.SmartServerResponse(('no',)), response)
 
1477
 
 
1478
 
 
1479
class TestSmartServerBranchRequestUnlock(TestLockedBranch):
1253
1480
 
1254
1481
    def setUp(self):
1255
1482
        tests.TestCaseWithMemoryTransport.setUp(self)
1259
1486
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
1260
1487
        branch = self.make_branch('.', format='knit')
1261
1488
        # Lock the branch
1262
 
        branch_token = branch.lock_write()
1263
 
        repo_token = branch.repository.lock_write()
1264
 
        branch.repository.unlock()
 
1489
        branch_token, repo_token = self.get_lock_tokens(branch)
1265
1490
        # Unlock the branch (and repo) object, leaving the physical locks
1266
1491
        # in place.
1267
1492
        branch.leave_lock_in_place()
1291
1516
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
1292
1517
        branch = self.make_branch('.', format='knit')
1293
1518
        # Lock the repository.
1294
 
        repo_token = branch.repository.lock_write()
 
1519
        repo_token = branch.repository.lock_write().repository_token
1295
1520
        branch.repository.leave_lock_in_place()
1296
1521
        branch.repository.unlock()
1297
1522
        # Issue branch lock_write request on the unlocked branch (with locked
1298
1523
        # repo).
1299
 
        response = request.execute(
1300
 
            '', 'branch token', repo_token)
 
1524
        response = request.execute('', 'branch token', repo_token)
1301
1525
        self.assertEqual(
1302
1526
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
1303
1527
        # Cleanup
1322
1546
            request.execute, 'subdir')
1323
1547
 
1324
1548
 
 
1549
class TestSmartServerRepositoryAddSignatureText(tests.TestCaseWithMemoryTransport):
 
1550
 
 
1551
    def test_add_text(self):
 
1552
        backing = self.get_transport()
 
1553
        request = smart_repo.SmartServerRepositoryAddSignatureText(backing)
 
1554
        tree = self.make_branch_and_memory_tree('.')
 
1555
        write_token = tree.lock_write()
 
1556
        self.addCleanup(tree.unlock)
 
1557
        tree.add('')
 
1558
        tree.commit("Message", rev_id='rev1')
 
1559
        tree.branch.repository.start_write_group()
 
1560
        write_group_tokens = tree.branch.repository.suspend_write_group()
 
1561
        self.assertEqual(None, request.execute('', write_token,
 
1562
            'rev1', *write_group_tokens))
 
1563
        response = request.do_body('somesignature')
 
1564
        self.assertTrue(response.is_successful())
 
1565
        self.assertEqual(response.args[0], 'ok')
 
1566
        write_group_tokens = response.args[1:]
 
1567
        tree.branch.repository.resume_write_group(write_group_tokens)
 
1568
        tree.branch.repository.commit_write_group()
 
1569
        tree.unlock()
 
1570
        self.assertEqual("somesignature",
 
1571
            tree.branch.repository.get_signature_text("rev1"))
 
1572
 
 
1573
 
 
1574
class TestSmartServerRepositoryAllRevisionIds(
 
1575
    tests.TestCaseWithMemoryTransport):
 
1576
 
 
1577
    def test_empty(self):
 
1578
        """An empty body should be returned for an empty repository."""
 
1579
        backing = self.get_transport()
 
1580
        request = smart_repo.SmartServerRepositoryAllRevisionIds(backing)
 
1581
        self.make_repository('.')
 
1582
        self.assertEquals(
 
1583
            smart_req.SuccessfulSmartServerResponse(("ok", ), ""),
 
1584
            request.execute(''))
 
1585
 
 
1586
    def test_some_revisions(self):
 
1587
        """An empty body should be returned for an empty repository."""
 
1588
        backing = self.get_transport()
 
1589
        request = smart_repo.SmartServerRepositoryAllRevisionIds(backing)
 
1590
        tree = self.make_branch_and_memory_tree('.')
 
1591
        tree.lock_write()
 
1592
        tree.add('')
 
1593
        tree.commit(rev_id='origineel', message="message")
 
1594
        tree.commit(rev_id='nog-een-revisie', message="message")
 
1595
        tree.unlock()
 
1596
        self.assertEquals(
 
1597
            smart_req.SuccessfulSmartServerResponse(("ok", ),
 
1598
                "origineel\nnog-een-revisie"),
 
1599
            request.execute(''))
 
1600
 
 
1601
 
 
1602
class TestSmartServerRepositoryBreakLock(tests.TestCaseWithMemoryTransport):
 
1603
 
 
1604
    def test_lock_to_break(self):
 
1605
        backing = self.get_transport()
 
1606
        request = smart_repo.SmartServerRepositoryBreakLock(backing)
 
1607
        tree = self.make_branch_and_memory_tree('.')
 
1608
        tree.branch.repository.lock_write()
 
1609
        self.assertEqual(
 
1610
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1611
            request.execute(''))
 
1612
 
 
1613
    def test_nothing_to_break(self):
 
1614
        backing = self.get_transport()
 
1615
        request = smart_repo.SmartServerRepositoryBreakLock(backing)
 
1616
        tree = self.make_branch_and_memory_tree('.')
 
1617
        self.assertEqual(
 
1618
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1619
            request.execute(''))
 
1620
 
 
1621
 
1325
1622
class TestSmartServerRepositoryGetParentMap(tests.TestCaseWithMemoryTransport):
1326
1623
 
1327
1624
    def test_trivial_bzipped(self):
1447
1744
            request.execute('stacked', 1, (3, r3)))
1448
1745
 
1449
1746
 
1450
 
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
 
1747
class TestSmartServerRepositoryIterRevisions(
 
1748
    tests.TestCaseWithMemoryTransport):
 
1749
 
 
1750
    def test_basic(self):
 
1751
        backing = self.get_transport()
 
1752
        request = smart_repo.SmartServerRepositoryIterRevisions(backing)
 
1753
        tree = self.make_branch_and_memory_tree('.', format='2a')
 
1754
        tree.lock_write()
 
1755
        tree.add('')
 
1756
        tree.commit('1st commit', rev_id="rev1")
 
1757
        tree.commit('2nd commit', rev_id="rev2")
 
1758
        tree.unlock()
 
1759
 
 
1760
        self.assertIs(None, request.execute(''))
 
1761
        response = request.do_body("rev1\nrev2")
 
1762
        self.assertTrue(response.is_successful())
 
1763
        # Format 2a uses serializer format 10
 
1764
        self.assertEquals(response.args, ("ok", "10"))
 
1765
 
 
1766
        self.addCleanup(tree.branch.lock_read().unlock)
 
1767
        entries = [zlib.compress(record.get_bytes_as("fulltext")) for record in
 
1768
            tree.branch.repository.revisions.get_record_stream(
 
1769
            [("rev1", ), ("rev2", )], "unordered", True)]
 
1770
 
 
1771
        contents = "".join(response.body_stream)
 
1772
        self.assertTrue(contents in (
 
1773
            "".join([entries[0], entries[1]]),
 
1774
            "".join([entries[1], entries[0]])))
 
1775
 
 
1776
    def test_missing(self):
 
1777
        backing = self.get_transport()
 
1778
        request = smart_repo.SmartServerRepositoryIterRevisions(backing)
 
1779
        tree = self.make_branch_and_memory_tree('.', format='2a')
 
1780
 
 
1781
        self.assertIs(None, request.execute(''))
 
1782
        response = request.do_body("rev1\nrev2")
 
1783
        self.assertTrue(response.is_successful())
 
1784
        # Format 2a uses serializer format 10
 
1785
        self.assertEquals(response.args, ("ok", "10"))
 
1786
 
 
1787
        contents = "".join(response.body_stream)
 
1788
        self.assertEquals(contents, "")
 
1789
 
 
1790
 
 
1791
class GetStreamTestBase(tests.TestCaseWithMemoryTransport):
1451
1792
 
1452
1793
    def make_two_commit_repo(self):
1453
1794
        tree = self.make_branch_and_memory_tree('.')
1459
1800
        repo = tree.branch.repository
1460
1801
        return repo, r1, r2
1461
1802
 
 
1803
 
 
1804
class TestSmartServerRepositoryGetStream(GetStreamTestBase):
 
1805
 
1462
1806
    def test_ancestry_of(self):
1463
1807
        """The search argument may be a 'ancestry-of' some heads'."""
1464
1808
        backing = self.get_transport()
1485
1829
        stream_bytes = ''.join(response.body_stream)
1486
1830
        self.assertStartsWith(stream_bytes, 'Bazaar pack format 1')
1487
1831
 
 
1832
    def test_search_everything(self):
 
1833
        """A search of 'everything' returns a stream."""
 
1834
        backing = self.get_transport()
 
1835
        request = smart_repo.SmartServerRepositoryGetStream_1_19(backing)
 
1836
        repo, r1, r2 = self.make_two_commit_repo()
 
1837
        serialised_fetch_spec = 'everything'
 
1838
        request.execute('', repo._format.network_name())
 
1839
        response = request.do_body(serialised_fetch_spec)
 
1840
        self.assertEqual(('ok',), response.args)
 
1841
        stream_bytes = ''.join(response.body_stream)
 
1842
        self.assertStartsWith(stream_bytes, 'Bazaar pack format 1')
 
1843
 
1488
1844
 
1489
1845
class TestSmartServerRequestHasRevision(tests.TestCaseWithMemoryTransport):
1490
1846
 
1511
1867
            request.execute('', rev_id_utf8))
1512
1868
 
1513
1869
 
 
1870
class TestSmartServerRepositoryIterFilesBytes(tests.TestCaseWithTransport):
 
1871
 
 
1872
    def test_single(self):
 
1873
        backing = self.get_transport()
 
1874
        request = smart_repo.SmartServerRepositoryIterFilesBytes(backing)
 
1875
        t = self.make_branch_and_tree('.')
 
1876
        self.addCleanup(t.lock_write().unlock)
 
1877
        self.build_tree_contents([("file", "somecontents")])
 
1878
        t.add(["file"], ["thefileid"])
 
1879
        t.commit(rev_id='somerev', message="add file")
 
1880
        self.assertIs(None, request.execute(''))
 
1881
        response = request.do_body("thefileid\0somerev\n")
 
1882
        self.assertTrue(response.is_successful())
 
1883
        self.assertEquals(response.args, ("ok", ))
 
1884
        self.assertEquals("".join(response.body_stream),
 
1885
            "ok\x000\n" + zlib.compress("somecontents"))
 
1886
 
 
1887
    def test_missing(self):
 
1888
        backing = self.get_transport()
 
1889
        request = smart_repo.SmartServerRepositoryIterFilesBytes(backing)
 
1890
        t = self.make_branch_and_tree('.')
 
1891
        self.addCleanup(t.lock_write().unlock)
 
1892
        self.assertIs(None, request.execute(''))
 
1893
        response = request.do_body("thefileid\0revision\n")
 
1894
        self.assertTrue(response.is_successful())
 
1895
        self.assertEquals(response.args, ("ok", ))
 
1896
        self.assertEquals("".join(response.body_stream),
 
1897
            "absent\x00thefileid\x00revision\x000\n")
 
1898
 
 
1899
 
 
1900
class TestSmartServerRequestHasSignatureForRevisionId(
 
1901
        tests.TestCaseWithMemoryTransport):
 
1902
 
 
1903
    def test_missing_revision(self):
 
1904
        """For a missing revision, NoSuchRevision is returned."""
 
1905
        backing = self.get_transport()
 
1906
        request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
 
1907
            backing)
 
1908
        self.make_repository('.')
 
1909
        self.assertEqual(
 
1910
            smart_req.FailedSmartServerResponse(
 
1911
                ('nosuchrevision', 'revid'), None),
 
1912
            request.execute('', 'revid'))
 
1913
 
 
1914
    def test_missing_signature(self):
 
1915
        """For a missing signature, ('no', ) is returned."""
 
1916
        backing = self.get_transport()
 
1917
        request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
 
1918
            backing)
 
1919
        tree = self.make_branch_and_memory_tree('.')
 
1920
        tree.lock_write()
 
1921
        tree.add('')
 
1922
        r1 = tree.commit('a commit', rev_id='A')
 
1923
        tree.unlock()
 
1924
        self.assertTrue(tree.branch.repository.has_revision('A'))
 
1925
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1926
            request.execute('', 'A'))
 
1927
 
 
1928
    def test_present_signature(self):
 
1929
        """For a present signature, ('yes', ) is returned."""
 
1930
        backing = self.get_transport()
 
1931
        request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
 
1932
            backing)
 
1933
        strategy = gpg.LoopbackGPGStrategy(None)
 
1934
        tree = self.make_branch_and_memory_tree('.')
 
1935
        tree.lock_write()
 
1936
        tree.add('')
 
1937
        r1 = tree.commit('a commit', rev_id='A')
 
1938
        tree.branch.repository.start_write_group()
 
1939
        tree.branch.repository.sign_revision('A', strategy)
 
1940
        tree.branch.repository.commit_write_group()
 
1941
        tree.unlock()
 
1942
        self.assertTrue(tree.branch.repository.has_revision('A'))
 
1943
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1944
            request.execute('', 'A'))
 
1945
 
 
1946
 
1514
1947
class TestSmartServerRepositoryGatherStats(tests.TestCaseWithMemoryTransport):
1515
1948
 
1516
1949
    def test_empty_revid(self):
1569
2002
                         request.execute('',
1570
2003
                                         rev_id_utf8, 'yes'))
1571
2004
 
 
2005
    def test_unknown_revid(self):
 
2006
        """An unknown revision id causes a 'nosuchrevision' error."""
 
2007
        backing = self.get_transport()
 
2008
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
2009
        repository = self.make_repository('.')
 
2010
        expected_body = 'revisions: 0\n'
 
2011
        self.assertEqual(
 
2012
            smart_req.FailedSmartServerResponse(
 
2013
                ('nosuchrevision', 'mia'), None),
 
2014
            request.execute('', 'mia', 'yes'))
 
2015
 
1572
2016
 
1573
2017
class TestSmartServerRepositoryIsShared(tests.TestCaseWithMemoryTransport):
1574
2018
 
1589
2033
            request.execute('', ))
1590
2034
 
1591
2035
 
 
2036
class TestSmartServerRepositoryGetRevisionSignatureText(
 
2037
        tests.TestCaseWithMemoryTransport):
 
2038
 
 
2039
    def test_get_signature(self):
 
2040
        backing = self.get_transport()
 
2041
        request = smart_repo.SmartServerRepositoryGetRevisionSignatureText(
 
2042
            backing)
 
2043
        bb = self.make_branch_builder('.')
 
2044
        bb.build_commit(rev_id='A')
 
2045
        repo = bb.get_branch().repository
 
2046
        strategy = gpg.LoopbackGPGStrategy(None)
 
2047
        self.addCleanup(repo.lock_write().unlock)
 
2048
        repo.start_write_group()
 
2049
        repo.sign_revision('A', strategy)
 
2050
        repo.commit_write_group()
 
2051
        expected_body = (
 
2052
            '-----BEGIN PSEUDO-SIGNED CONTENT-----\n' +
 
2053
            Testament.from_revision(repo, 'A').as_short_text() +
 
2054
            '-----END PSEUDO-SIGNED CONTENT-----\n')
 
2055
        self.assertEqual(
 
2056
            smart_req.SmartServerResponse(('ok', ), expected_body),
 
2057
            request.execute('', 'A'))
 
2058
 
 
2059
 
 
2060
class TestSmartServerRepositoryMakeWorkingTrees(
 
2061
        tests.TestCaseWithMemoryTransport):
 
2062
 
 
2063
    def test_make_working_trees(self):
 
2064
        """For a repository with working trees, ('yes', ) is returned."""
 
2065
        backing = self.get_transport()
 
2066
        request = smart_repo.SmartServerRepositoryMakeWorkingTrees(backing)
 
2067
        r = self.make_repository('.')
 
2068
        r.set_make_working_trees(True)
 
2069
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
2070
            request.execute('', ))
 
2071
 
 
2072
    def test_is_not_shared(self):
 
2073
        """For a repository with working trees, ('no', ) is returned."""
 
2074
        backing = self.get_transport()
 
2075
        request = smart_repo.SmartServerRepositoryMakeWorkingTrees(backing)
 
2076
        r = self.make_repository('.')
 
2077
        r.set_make_working_trees(False)
 
2078
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
2079
            request.execute('', ))
 
2080
 
 
2081
 
1592
2082
class TestSmartServerRepositoryLockWrite(tests.TestCaseWithMemoryTransport):
1593
2083
 
1594
2084
    def test_lock_write_on_unlocked_repo(self):
1610
2100
        backing = self.get_transport()
1611
2101
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
1612
2102
        repository = self.make_repository('.', format='knit')
1613
 
        repo_token = repository.lock_write()
 
2103
        repo_token = repository.lock_write().repository_token
1614
2104
        repository.leave_lock_in_place()
1615
2105
        repository.unlock()
1616
2106
        response = request.execute('')
1658
2148
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1659
2149
            backing)
1660
2150
        repository = self.make_repository('.', format='knit')
1661
 
        lock_token = repository.lock_write()
 
2151
        lock_token = repository.lock_write().repository_token
1662
2152
        response = request.execute('', '', lock_token)
1663
2153
        self.assertEqual(None, response)
1664
2154
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1672
2162
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1673
2163
            backing)
1674
2164
        repository = self.make_repository('.', format='knit')
1675
 
        lock_token = repository.lock_write()
 
2165
        lock_token = repository.lock_write().repository_token
1676
2166
        self.assertRaises(
1677
2167
            errors.TokenMismatch, request.execute, '', '', 'wrong-token')
1678
2168
        repository.unlock()
1687
2177
        backing = self.get_transport()
1688
2178
        request = smart_repo.SmartServerRepositoryUnlock(backing)
1689
2179
        repository = self.make_repository('.', format='knit')
1690
 
        token = repository.lock_write()
 
2180
        token = repository.lock_write().repository_token
1691
2181
        repository.leave_lock_in_place()
1692
2182
        repository.unlock()
1693
2183
        response = request.execute('', token)
1708
2198
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
1709
2199
 
1710
2200
 
 
2201
class TestSmartServerRepositoryGetPhysicalLockStatus(
 
2202
    tests.TestCaseWithTransport):
 
2203
 
 
2204
    def test_with_write_lock(self):
 
2205
        backing = self.get_transport()
 
2206
        repo = self.make_repository('.')
 
2207
        self.addCleanup(repo.lock_write().unlock)
 
2208
        # lock_write() doesn't necessarily actually take a physical
 
2209
        # lock out.
 
2210
        if repo.get_physical_lock_status():
 
2211
            expected = 'yes'
 
2212
        else:
 
2213
            expected = 'no'
 
2214
        request_class = smart_repo.SmartServerRepositoryGetPhysicalLockStatus
 
2215
        request = request_class(backing)
 
2216
        self.assertEqual(smart_req.SuccessfulSmartServerResponse((expected,)),
 
2217
            request.execute('', ))
 
2218
 
 
2219
    def test_without_write_lock(self):
 
2220
        backing = self.get_transport()
 
2221
        repo = self.make_repository('.')
 
2222
        self.assertEquals(False, repo.get_physical_lock_status())
 
2223
        request_class = smart_repo.SmartServerRepositoryGetPhysicalLockStatus
 
2224
        request = request_class(backing)
 
2225
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('no',)),
 
2226
            request.execute('', ))
 
2227
 
 
2228
 
 
2229
class TestSmartServerRepositoryReconcile(tests.TestCaseWithTransport):
 
2230
 
 
2231
    def test_reconcile(self):
 
2232
        backing = self.get_transport()
 
2233
        repo = self.make_repository('.')
 
2234
        token = repo.lock_write().repository_token
 
2235
        self.addCleanup(repo.unlock)
 
2236
        request_class = smart_repo.SmartServerRepositoryReconcile
 
2237
        request = request_class(backing)
 
2238
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
 
2239
            ('ok', ),
 
2240
             'garbage_inventories: 0\n'
 
2241
             'inconsistent_parents: 0\n'),
 
2242
            request.execute('', token))
 
2243
 
 
2244
 
1711
2245
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1712
2246
 
1713
2247
    def test_is_readonly_no(self):
1751
2285
        self.assertTrue(repo.make_working_trees())
1752
2286
 
1753
2287
 
 
2288
class TestSmartServerRepositoryGetSerializerFormat(
 
2289
    tests.TestCaseWithMemoryTransport):
 
2290
 
 
2291
    def test_get_serializer_format(self):
 
2292
        backing = self.get_transport()
 
2293
        repo = self.make_repository('.', format='2a')
 
2294
        request_class = smart_repo.SmartServerRepositoryGetSerializerFormat
 
2295
        request = request_class(backing)
 
2296
        self.assertEqual(
 
2297
            smart_req.SuccessfulSmartServerResponse(('ok', '10')),
 
2298
            request.execute(''))
 
2299
 
 
2300
 
 
2301
class TestSmartServerRepositoryWriteGroup(
 
2302
    tests.TestCaseWithMemoryTransport):
 
2303
 
 
2304
    def test_start_write_group(self):
 
2305
        backing = self.get_transport()
 
2306
        repo = self.make_repository('.')
 
2307
        lock_token = repo.lock_write().repository_token
 
2308
        self.addCleanup(repo.unlock)
 
2309
        request_class = smart_repo.SmartServerRepositoryStartWriteGroup
 
2310
        request = request_class(backing)
 
2311
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok', [])),
 
2312
            request.execute('', lock_token))
 
2313
 
 
2314
    def test_start_write_group_unsuspendable(self):
 
2315
        backing = self.get_transport()
 
2316
        repo = self.make_repository('.', format='knit')
 
2317
        lock_token = repo.lock_write().repository_token
 
2318
        self.addCleanup(repo.unlock)
 
2319
        request_class = smart_repo.SmartServerRepositoryStartWriteGroup
 
2320
        request = request_class(backing)
 
2321
        self.assertEqual(
 
2322
            smart_req.FailedSmartServerResponse(('UnsuspendableWriteGroup',)),
 
2323
            request.execute('', lock_token))
 
2324
 
 
2325
    def test_commit_write_group(self):
 
2326
        backing = self.get_transport()
 
2327
        repo = self.make_repository('.')
 
2328
        lock_token = repo.lock_write().repository_token
 
2329
        self.addCleanup(repo.unlock)
 
2330
        repo.start_write_group()
 
2331
        tokens = repo.suspend_write_group()
 
2332
        request_class = smart_repo.SmartServerRepositoryCommitWriteGroup
 
2333
        request = request_class(backing)
 
2334
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
2335
            request.execute('', lock_token, tokens))
 
2336
 
 
2337
    def test_abort_write_group(self):
 
2338
        backing = self.get_transport()
 
2339
        repo = self.make_repository('.')
 
2340
        lock_token = repo.lock_write().repository_token
 
2341
        repo.start_write_group()
 
2342
        tokens = repo.suspend_write_group()
 
2343
        self.addCleanup(repo.unlock)
 
2344
        request_class = smart_repo.SmartServerRepositoryAbortWriteGroup
 
2345
        request = request_class(backing)
 
2346
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
2347
            request.execute('', lock_token, tokens))
 
2348
 
 
2349
    def test_check_write_group(self):
 
2350
        backing = self.get_transport()
 
2351
        repo = self.make_repository('.')
 
2352
        lock_token = repo.lock_write().repository_token
 
2353
        repo.start_write_group()
 
2354
        tokens = repo.suspend_write_group()
 
2355
        self.addCleanup(repo.unlock)
 
2356
        request_class = smart_repo.SmartServerRepositoryCheckWriteGroup
 
2357
        request = request_class(backing)
 
2358
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
2359
            request.execute('', lock_token, tokens))
 
2360
 
 
2361
    def test_check_write_group_invalid(self):
 
2362
        backing = self.get_transport()
 
2363
        repo = self.make_repository('.')
 
2364
        lock_token = repo.lock_write().repository_token
 
2365
        self.addCleanup(repo.unlock)
 
2366
        request_class = smart_repo.SmartServerRepositoryCheckWriteGroup
 
2367
        request = request_class(backing)
 
2368
        self.assertEqual(smart_req.FailedSmartServerResponse(
 
2369
            ('UnresumableWriteGroup', ['random'],
 
2370
                'Malformed write group token')),
 
2371
            request.execute('', lock_token, ["random"]))
 
2372
 
 
2373
 
1754
2374
class TestSmartServerPackRepositoryAutopack(tests.TestCaseWithTransport):
1755
2375
 
1756
2376
    def make_repo_needing_autopacking(self, path='.'):
1822
2442
        """All registered request_handlers can be found."""
1823
2443
        # If there's a typo in a register_lazy call, this loop will fail with
1824
2444
        # an AttributeError.
1825
 
        for key, item in smart_req.request_handlers.iteritems():
1826
 
            pass
 
2445
        for key in smart_req.request_handlers.keys():
 
2446
            try:
 
2447
                item = smart_req.request_handlers.get(key)
 
2448
            except AttributeError, e:
 
2449
                raise AttributeError('failed to get %s: %s' % (key, e))
1827
2450
 
1828
2451
    def assertHandlerEqual(self, verb, handler):
1829
2452
        self.assertEqual(smart_req.request_handlers.get(verb), handler)
1830
2453
 
1831
2454
    def test_registered_methods(self):
1832
2455
        """Test that known methods are registered to the correct object."""
 
2456
        self.assertHandlerEqual('Branch.break_lock',
 
2457
            smart_branch.SmartServerBranchBreakLock)
1833
2458
        self.assertHandlerEqual('Branch.get_config_file',
1834
2459
            smart_branch.SmartServerBranchGetConfigFile)
 
2460
        self.assertHandlerEqual('Branch.put_config_file',
 
2461
            smart_branch.SmartServerBranchPutConfigFile)
1835
2462
        self.assertHandlerEqual('Branch.get_parent',
1836
2463
            smart_branch.SmartServerBranchGetParent)
 
2464
        self.assertHandlerEqual('Branch.get_physical_lock_status',
 
2465
            smart_branch.SmartServerBranchRequestGetPhysicalLockStatus)
1837
2466
        self.assertHandlerEqual('Branch.get_tags_bytes',
1838
2467
            smart_branch.SmartServerBranchGetTagsBytes)
1839
2468
        self.assertHandlerEqual('Branch.lock_write',
1842
2471
            smart_branch.SmartServerBranchRequestLastRevisionInfo)
1843
2472
        self.assertHandlerEqual('Branch.revision_history',
1844
2473
            smart_branch.SmartServerRequestRevisionHistory)
 
2474
        self.assertHandlerEqual('Branch.revision_id_to_revno',
 
2475
            smart_branch.SmartServerBranchRequestRevisionIdToRevno)
1845
2476
        self.assertHandlerEqual('Branch.set_config_option',
1846
2477
            smart_branch.SmartServerBranchRequestSetConfigOption)
1847
2478
        self.assertHandlerEqual('Branch.set_last_revision',
1854
2485
            smart_branch.SmartServerBranchRequestSetParentLocation)
1855
2486
        self.assertHandlerEqual('Branch.unlock',
1856
2487
            smart_branch.SmartServerBranchRequestUnlock)
 
2488
        self.assertHandlerEqual('BzrDir.destroy_branch',
 
2489
            smart_dir.SmartServerBzrDirRequestDestroyBranch)
1857
2490
        self.assertHandlerEqual('BzrDir.find_repository',
1858
2491
            smart_dir.SmartServerRequestFindRepositoryV1)
1859
2492
        self.assertHandlerEqual('BzrDir.find_repositoryV2',
1862
2495
            smart_dir.SmartServerRequestInitializeBzrDir)
1863
2496
        self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
1864
2497
            smart_dir.SmartServerRequestBzrDirInitializeEx)
 
2498
        self.assertHandlerEqual('BzrDir.checkout_metadir',
 
2499
            smart_dir.SmartServerBzrDirRequestCheckoutMetaDir)
1865
2500
        self.assertHandlerEqual('BzrDir.cloning_metadir',
1866
2501
            smart_dir.SmartServerBzrDirRequestCloningMetaDir)
1867
2502
        self.assertHandlerEqual('BzrDir.get_config_file',
1874
2509
            smart_dir.SmartServerRequestOpenBranchV3)
1875
2510
        self.assertHandlerEqual('PackRepository.autopack',
1876
2511
            smart_packrepo.SmartServerPackRepositoryAutopack)
 
2512
        self.assertHandlerEqual('Repository.add_signature_text',
 
2513
            smart_repo.SmartServerRepositoryAddSignatureText)
 
2514
        self.assertHandlerEqual('Repository.all_revision_ids',
 
2515
            smart_repo.SmartServerRepositoryAllRevisionIds)
 
2516
        self.assertHandlerEqual('Repository.break_lock',
 
2517
            smart_repo.SmartServerRepositoryBreakLock)
1877
2518
        self.assertHandlerEqual('Repository.gather_stats',
1878
2519
            smart_repo.SmartServerRepositoryGatherStats)
1879
2520
        self.assertHandlerEqual('Repository.get_parent_map',
1880
2521
            smart_repo.SmartServerRepositoryGetParentMap)
 
2522
        self.assertHandlerEqual('Repository.get_physical_lock_status',
 
2523
            smart_repo.SmartServerRepositoryGetPhysicalLockStatus)
1881
2524
        self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1882
2525
            smart_repo.SmartServerRepositoryGetRevIdForRevno)
1883
2526
        self.assertHandlerEqual('Repository.get_revision_graph',
1884
2527
            smart_repo.SmartServerRepositoryGetRevisionGraph)
 
2528
        self.assertHandlerEqual('Repository.get_revision_signature_text',
 
2529
            smart_repo.SmartServerRepositoryGetRevisionSignatureText)
1885
2530
        self.assertHandlerEqual('Repository.get_stream',
1886
2531
            smart_repo.SmartServerRepositoryGetStream)
 
2532
        self.assertHandlerEqual('Repository.get_stream_1.19',
 
2533
            smart_repo.SmartServerRepositoryGetStream_1_19)
 
2534
        self.assertHandlerEqual('Repository.iter_revisions',
 
2535
            smart_repo.SmartServerRepositoryIterRevisions)
1887
2536
        self.assertHandlerEqual('Repository.has_revision',
1888
2537
            smart_repo.SmartServerRequestHasRevision)
1889
2538
        self.assertHandlerEqual('Repository.insert_stream',
1892
2541
            smart_repo.SmartServerRepositoryInsertStreamLocked)
1893
2542
        self.assertHandlerEqual('Repository.is_shared',
1894
2543
            smart_repo.SmartServerRepositoryIsShared)
 
2544
        self.assertHandlerEqual('Repository.iter_files_bytes',
 
2545
            smart_repo.SmartServerRepositoryIterFilesBytes)
1895
2546
        self.assertHandlerEqual('Repository.lock_write',
1896
2547
            smart_repo.SmartServerRepositoryLockWrite)
 
2548
        self.assertHandlerEqual('Repository.make_working_trees',
 
2549
            smart_repo.SmartServerRepositoryMakeWorkingTrees)
 
2550
        self.assertHandlerEqual('Repository.pack',
 
2551
            smart_repo.SmartServerRepositoryPack)
 
2552
        self.assertHandlerEqual('Repository.reconcile',
 
2553
            smart_repo.SmartServerRepositoryReconcile)
1897
2554
        self.assertHandlerEqual('Repository.tarball',
1898
2555
            smart_repo.SmartServerRepositoryTarball)
1899
2556
        self.assertHandlerEqual('Repository.unlock',
1900
2557
            smart_repo.SmartServerRepositoryUnlock)
 
2558
        self.assertHandlerEqual('Repository.start_write_group',
 
2559
            smart_repo.SmartServerRepositoryStartWriteGroup)
 
2560
        self.assertHandlerEqual('Repository.check_write_group',
 
2561
            smart_repo.SmartServerRepositoryCheckWriteGroup)
 
2562
        self.assertHandlerEqual('Repository.commit_write_group',
 
2563
            smart_repo.SmartServerRepositoryCommitWriteGroup)
 
2564
        self.assertHandlerEqual('Repository.abort_write_group',
 
2565
            smart_repo.SmartServerRepositoryAbortWriteGroup)
 
2566
        self.assertHandlerEqual('VersionedFileRepository.get_serializer_format',
 
2567
            smart_repo.SmartServerRepositoryGetSerializerFormat)
1901
2568
        self.assertHandlerEqual('Transport.is_readonly',
1902
2569
            smart_req.SmartServerIsReadonly)
 
2570
 
 
2571
 
 
2572
class SmartTCPServerHookTests(tests.TestCaseWithMemoryTransport):
 
2573
    """Tests for SmartTCPServer hooks."""
 
2574
 
 
2575
    def setUp(self):
 
2576
        super(SmartTCPServerHookTests, self).setUp()
 
2577
        self.server = server.SmartTCPServer(self.get_transport())
 
2578
 
 
2579
    def test_run_server_started_hooks(self):
 
2580
        """Test the server started hooks get fired properly."""
 
2581
        started_calls = []
 
2582
        server.SmartTCPServer.hooks.install_named_hook('server_started',
 
2583
            lambda backing_urls, url: started_calls.append((backing_urls, url)),
 
2584
            None)
 
2585
        started_ex_calls = []
 
2586
        server.SmartTCPServer.hooks.install_named_hook('server_started_ex',
 
2587
            lambda backing_urls, url: started_ex_calls.append((backing_urls, url)),
 
2588
            None)
 
2589
        self.server._sockname = ('example.com', 42)
 
2590
        self.server.run_server_started_hooks()
 
2591
        self.assertEquals(started_calls,
 
2592
            [([self.get_transport().base], 'bzr://example.com:42/')])
 
2593
        self.assertEquals(started_ex_calls,
 
2594
            [([self.get_transport().base], self.server)])
 
2595
 
 
2596
    def test_run_server_started_hooks_ipv6(self):
 
2597
        """Test that socknames can contain 4-tuples."""
 
2598
        self.server._sockname = ('::', 42, 0, 0)
 
2599
        started_calls = []
 
2600
        server.SmartTCPServer.hooks.install_named_hook('server_started',
 
2601
            lambda backing_urls, url: started_calls.append((backing_urls, url)),
 
2602
            None)
 
2603
        self.server.run_server_started_hooks()
 
2604
        self.assertEquals(started_calls,
 
2605
                [([self.get_transport().base], 'bzr://:::42/')])
 
2606
 
 
2607
    def test_run_server_stopped_hooks(self):
 
2608
        """Test the server stopped hooks."""
 
2609
        self.server._sockname = ('example.com', 42)
 
2610
        stopped_calls = []
 
2611
        server.SmartTCPServer.hooks.install_named_hook('server_stopped',
 
2612
            lambda backing_urls, url: stopped_calls.append((backing_urls, url)),
 
2613
            None)
 
2614
        self.server.run_server_stopped_hooks()
 
2615
        self.assertEquals(stopped_calls,
 
2616
            [([self.get_transport().base], 'bzr://example.com:42/')])
 
2617
 
 
2618
 
 
2619
class TestSmartServerRepositoryPack(tests.TestCaseWithMemoryTransport):
 
2620
 
 
2621
    def test_pack(self):
 
2622
        backing = self.get_transport()
 
2623
        request = smart_repo.SmartServerRepositoryPack(backing)
 
2624
        tree = self.make_branch_and_memory_tree('.')
 
2625
        repo_token = tree.branch.repository.lock_write().repository_token
 
2626
 
 
2627
        self.assertIs(None, request.execute('', repo_token, False))
 
2628
 
 
2629
        self.assertEqual(
 
2630
            smart_req.SuccessfulSmartServerResponse(('ok', ), ),
 
2631
            request.do_body(''))
 
2632