← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Jelmer Vernooij
  • Date: 2011-11-25 17:54:52 UTC
  • mfrom: (6303 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6321.
  • Revision ID: jelmer@samba.org-20111125175452-v0uwwxqcp97tzuzv
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart.py
30
30
    branch as _mod_branch,
31
31
    bzrdir,
32
32
    errors,
 
33
    gpg,
33
34
    tests,
34
35
    transport,
35
36
    urlutils,
221
222
        self.assertEqual(expected, request.execute('', 'False'))
222
223
 
223
224
 
 
225
class TestSmartServerBzrDirRequestDestroyBranch(
 
226
    tests.TestCaseWithMemoryTransport):
 
227
    """Tests for BzrDir.destroy_branch."""
 
228
 
 
229
    def test_destroy_branch_default(self):
 
230
        """The default branch can be removed."""
 
231
        backing = self.get_transport()
 
232
        dir = self.make_branch('.').bzrdir
 
233
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
 
234
        request = request_class(backing)
 
235
        expected = smart_req.SuccessfulSmartServerResponse(('ok',))
 
236
        self.assertEqual(expected, request.execute('', None))
 
237
 
 
238
    def test_destroy_branch_named(self):
 
239
        """A named branch can be removed."""
 
240
        backing = self.get_transport()
 
241
        dir = self.make_repository('.', format="development-colo").bzrdir
 
242
        dir.create_branch(name="branchname")
 
243
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
 
244
        request = request_class(backing)
 
245
        expected = smart_req.SuccessfulSmartServerResponse(('ok',))
 
246
        self.assertEqual(expected, request.execute('', "branchname"))
 
247
 
 
248
    def test_destroy_branch_missing(self):
 
249
        """An error is raised if the branch didn't exist."""
 
250
        backing = self.get_transport()
 
251
        dir = self.make_bzrdir('.', format="development-colo")
 
252
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
 
253
        request = request_class(backing)
 
254
        expected = smart_req.FailedSmartServerResponse(('nobranch',), None)
 
255
        self.assertEqual(expected, request.execute('', "branchname"))
 
256
 
 
257
 
 
258
class TestSmartServerBzrDirRequestHasWorkingTree(
 
259
    tests.TestCaseWithTransport):
 
260
    """Tests for BzrDir.has_workingtree."""
 
261
 
 
262
    def test_has_workingtree_yes(self):
 
263
        """A working tree is present."""
 
264
        backing = self.get_transport()
 
265
        dir = self.make_branch_and_tree('.').bzrdir
 
266
        request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
 
267
        request = request_class(backing)
 
268
        expected = smart_req.SuccessfulSmartServerResponse(('yes',))
 
269
        self.assertEqual(expected, request.execute(''))
 
270
 
 
271
    def test_has_workingtree_no(self):
 
272
        """A working tree is missing."""
 
273
        backing = self.get_transport()
 
274
        dir = self.make_bzrdir('.')
 
275
        request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
 
276
        request = request_class(backing)
 
277
        expected = smart_req.SuccessfulSmartServerResponse(('no',))
 
278
        self.assertEqual(expected, request.execute(''))
 
279
 
 
280
 
 
281
class TestSmartServerBzrDirRequestDestroyRepository(
 
282
    tests.TestCaseWithMemoryTransport):
 
283
    """Tests for BzrDir.destroy_repository."""
 
284
 
 
285
    def test_destroy_repository_default(self):
 
286
        """The repository can be removed."""
 
287
        backing = self.get_transport()
 
288
        dir = self.make_repository('.').bzrdir
 
289
        request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
 
290
        request = request_class(backing)
 
291
        expected = smart_req.SuccessfulSmartServerResponse(('ok',))
 
292
        self.assertEqual(expected, request.execute(''))
 
293
 
 
294
    def test_destroy_repository_missing(self):
 
295
        """An error is raised if the repository didn't exist."""
 
296
        backing = self.get_transport()
 
297
        dir = self.make_bzrdir('.')
 
298
        request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
 
299
        request = request_class(backing)
 
300
        expected = smart_req.FailedSmartServerResponse(
 
301
            ('norepository',), None)
 
302
        self.assertEqual(expected, request.execute(''))
 
303
 
 
304
 
224
305
class TestSmartServerRequestCreateRepository(tests.TestCaseWithMemoryTransport):
225
306
    """Tests for BzrDir.create_repository."""
226
307
 
735
816
            request.execute(''))
736
817
 
737
818
 
 
819
class TestSmartServerBranchRequestRevisionIdToRevno(
 
820
    tests.TestCaseWithMemoryTransport):
 
821
 
 
822
    def test_null(self):
 
823
        backing = self.get_transport()
 
824
        request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
 
825
            backing)
 
826
        self.make_branch('.')
 
827
        self.assertEqual(smart_req.SmartServerResponse(('ok', '0')),
 
828
            request.execute('', 'null:'))
 
829
 
 
830
    def test_simple(self):
 
831
        backing = self.get_transport()
 
832
        request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
 
833
            backing)
 
834
        tree = self.make_branch_and_memory_tree('.')
 
835
        tree.lock_write()
 
836
        tree.add('')
 
837
        r1 = tree.commit('1st commit')
 
838
        tree.unlock()
 
839
        self.assertEqual(
 
840
            smart_req.SmartServerResponse(('ok', '1')),
 
841
            request.execute('', r1))
 
842
 
 
843
    def test_not_found(self):
 
844
        backing = self.get_transport()
 
845
        request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
 
846
            backing)
 
847
        branch = self.make_branch('.')
 
848
        self.assertEqual(
 
849
            smart_req.FailedSmartServerResponse(
 
850
                ('NoSuchRevision', 'idontexist')),
 
851
            request.execute('', 'idontexist'))
 
852
 
 
853
 
738
854
class TestSmartServerBranchRequestGetConfigFile(
739
855
    tests.TestCaseWithMemoryTransport):
740
856
 
769
885
        return branch_token, repo_token
770
886
 
771
887
 
 
888
class TestSmartServerBranchRequestPutConfigFile(TestLockedBranch):
 
889
 
 
890
    def test_with_content(self):
 
891
        backing = self.get_transport()
 
892
        request = smart_branch.SmartServerBranchPutConfigFile(backing)
 
893
        branch = self.make_branch('.')
 
894
        branch_token, repo_token = self.get_lock_tokens(branch)
 
895
        self.assertIs(None, request.execute('', branch_token, repo_token))
 
896
        self.assertEqual(
 
897
            smart_req.SmartServerResponse(('ok', )),
 
898
            request.do_body('foo bar baz'))
 
899
        self.assertEquals(
 
900
            branch.control_transport.get_bytes('branch.conf'),
 
901
            'foo bar baz')
 
902
        branch.unlock()
 
903
 
 
904
 
772
905
class TestSmartServerBranchRequestSetConfigOption(TestLockedBranch):
773
906
 
774
907
    def test_value_name(self):
1088
1221
        self.assertEqual('child-1', self.tree.branch.last_revision())
1089
1222
 
1090
1223
 
 
1224
class TestSmartServerBranchBreakLock(tests.TestCaseWithMemoryTransport):
 
1225
 
 
1226
    def test_lock_to_break(self):
 
1227
        base_branch = self.make_branch('base')
 
1228
        request = smart_branch.SmartServerBranchBreakLock(
 
1229
            self.get_transport())
 
1230
        base_branch.lock_write()
 
1231
        self.assertEqual(
 
1232
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1233
            request.execute('base'))
 
1234
 
 
1235
    def test_nothing_to_break(self):
 
1236
        base_branch = self.make_branch('base')
 
1237
        request = smart_branch.SmartServerBranchBreakLock(
 
1238
            self.get_transport())
 
1239
        self.assertEqual(
 
1240
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1241
            request.execute('base'))
 
1242
 
 
1243
 
1091
1244
class TestSmartServerBranchRequestGetParent(tests.TestCaseWithMemoryTransport):
1092
1245
 
1093
1246
    def test_get_parent_none(self):
1275
1428
        self.assertEqual('LockFailed', error_name)
1276
1429
 
1277
1430
 
 
1431
class TestSmartServerBranchRequestGetPhysicalLockStatus(TestLockedBranch):
 
1432
 
 
1433
    def setUp(self):
 
1434
        tests.TestCaseWithMemoryTransport.setUp(self)
 
1435
 
 
1436
    def test_true(self):
 
1437
        backing = self.get_transport()
 
1438
        request = smart_branch.SmartServerBranchRequestGetPhysicalLockStatus(
 
1439
            backing)
 
1440
        branch = self.make_branch('.')
 
1441
        branch_token, repo_token = self.get_lock_tokens(branch)
 
1442
        self.assertEquals(True, branch.get_physical_lock_status())
 
1443
        response = request.execute('')
 
1444
        self.assertEqual(
 
1445
            smart_req.SmartServerResponse(('yes',)), response)
 
1446
        branch.unlock()
 
1447
 
 
1448
    def test_false(self):
 
1449
        backing = self.get_transport()
 
1450
        request = smart_branch.SmartServerBranchRequestGetPhysicalLockStatus(
 
1451
            backing)
 
1452
        branch = self.make_branch('.')
 
1453
        self.assertEquals(False, branch.get_physical_lock_status())
 
1454
        response = request.execute('')
 
1455
        self.assertEqual(
 
1456
            smart_req.SmartServerResponse(('no',)), response)
 
1457
 
 
1458
 
1278
1459
class TestSmartServerBranchRequestUnlock(TestLockedBranch):
1279
1460
 
1280
1461
    def setUp(self):
1345
1526
            request.execute, 'subdir')
1346
1527
 
1347
1528
 
 
1529
class TestSmartServerRepositoryAllRevisionIds(
 
1530
    tests.TestCaseWithMemoryTransport):
 
1531
 
 
1532
    def test_empty(self):
 
1533
        """An empty body should be returned for an empty repository."""
 
1534
        backing = self.get_transport()
 
1535
        request = smart_repo.SmartServerRepositoryAllRevisionIds(backing)
 
1536
        self.make_repository('.')
 
1537
        self.assertEquals(
 
1538
            smart_req.SuccessfulSmartServerResponse(("ok", ), ""),
 
1539
            request.execute(''))
 
1540
 
 
1541
    def test_some_revisions(self):
 
1542
        """An empty body should be returned for an empty repository."""
 
1543
        backing = self.get_transport()
 
1544
        request = smart_repo.SmartServerRepositoryAllRevisionIds(backing)
 
1545
        tree = self.make_branch_and_memory_tree('.')
 
1546
        tree.lock_write()
 
1547
        tree.add('')
 
1548
        tree.commit(rev_id='origineel', message="message")
 
1549
        tree.commit(rev_id='nog-een-revisie', message="message")
 
1550
        tree.unlock()
 
1551
        self.assertEquals(
 
1552
            smart_req.SuccessfulSmartServerResponse(("ok", ),
 
1553
                "origineel\nnog-een-revisie"),
 
1554
            request.execute(''))
 
1555
 
 
1556
 
 
1557
class TestSmartServerRepositoryBreakLock(tests.TestCaseWithMemoryTransport):
 
1558
 
 
1559
    def test_lock_to_break(self):
 
1560
        backing = self.get_transport()
 
1561
        request = smart_repo.SmartServerRepositoryBreakLock(backing)
 
1562
        tree = self.make_branch_and_memory_tree('.')
 
1563
        tree.branch.repository.lock_write()
 
1564
        self.assertEqual(
 
1565
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1566
            request.execute(''))
 
1567
 
 
1568
    def test_nothing_to_break(self):
 
1569
        backing = self.get_transport()
 
1570
        request = smart_repo.SmartServerRepositoryBreakLock(backing)
 
1571
        tree = self.make_branch_and_memory_tree('.')
 
1572
        self.assertEqual(
 
1573
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1574
            request.execute(''))
 
1575
 
 
1576
 
1348
1577
class TestSmartServerRepositoryGetParentMap(tests.TestCaseWithMemoryTransport):
1349
1578
 
1350
1579
    def test_trivial_bzipped(self):
1549
1778
            request.execute('', rev_id_utf8))
1550
1779
 
1551
1780
 
 
1781
class TestSmartServerRequestHasSignatureForRevisionId(
 
1782
        tests.TestCaseWithMemoryTransport):
 
1783
 
 
1784
    def test_missing_revision(self):
 
1785
        """For a missing revision, NoSuchRevision is returned."""
 
1786
        backing = self.get_transport()
 
1787
        request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
 
1788
            backing)
 
1789
        self.make_repository('.')
 
1790
        self.assertEqual(
 
1791
            smart_req.FailedSmartServerResponse(
 
1792
                ('nosuchrevision', 'revid'), None),
 
1793
            request.execute('', 'revid'))
 
1794
 
 
1795
    def test_missing_signature(self):
 
1796
        """For a missing signature, ('no', ) is returned."""
 
1797
        backing = self.get_transport()
 
1798
        request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
 
1799
            backing)
 
1800
        tree = self.make_branch_and_memory_tree('.')
 
1801
        tree.lock_write()
 
1802
        tree.add('')
 
1803
        r1 = tree.commit('a commit', rev_id='A')
 
1804
        tree.unlock()
 
1805
        self.assertTrue(tree.branch.repository.has_revision('A'))
 
1806
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1807
            request.execute('', 'A'))
 
1808
 
 
1809
    def test_present_signature(self):
 
1810
        """For a present signature, ('yes', ) is returned."""
 
1811
        backing = self.get_transport()
 
1812
        request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
 
1813
            backing)
 
1814
        strategy = gpg.LoopbackGPGStrategy(None)
 
1815
        tree = self.make_branch_and_memory_tree('.')
 
1816
        tree.lock_write()
 
1817
        tree.add('')
 
1818
        r1 = tree.commit('a commit', rev_id='A')
 
1819
        tree.branch.repository.start_write_group()
 
1820
        tree.branch.repository.sign_revision('A', strategy)
 
1821
        tree.branch.repository.commit_write_group()
 
1822
        tree.unlock()
 
1823
        self.assertTrue(tree.branch.repository.has_revision('A'))
 
1824
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1825
            request.execute('', 'A'))
 
1826
 
 
1827
 
1552
1828
class TestSmartServerRepositoryGatherStats(tests.TestCaseWithMemoryTransport):
1553
1829
 
1554
1830
    def test_empty_revid(self):
1607
1883
                         request.execute('',
1608
1884
                                         rev_id_utf8, 'yes'))
1609
1885
 
 
1886
    def test_unknown_revid(self):
 
1887
        """An unknown revision id causes a 'nosuchrevision' error."""
 
1888
        backing = self.get_transport()
 
1889
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1890
        repository = self.make_repository('.')
 
1891
        expected_body = 'revisions: 0\n'
 
1892
        self.assertEqual(
 
1893
            smart_req.FailedSmartServerResponse(
 
1894
                ('nosuchrevision', 'mia'), None),
 
1895
            request.execute('', 'mia', 'yes'))
 
1896
 
1610
1897
 
1611
1898
class TestSmartServerRepositoryIsShared(tests.TestCaseWithMemoryTransport):
1612
1899
 
1627
1914
            request.execute('', ))
1628
1915
 
1629
1916
 
 
1917
class TestSmartServerRepositoryMakeWorkingTrees(
 
1918
        tests.TestCaseWithMemoryTransport):
 
1919
 
 
1920
    def test_make_working_trees(self):
 
1921
        """For a repository with working trees, ('yes', ) is returned."""
 
1922
        backing = self.get_transport()
 
1923
        request = smart_repo.SmartServerRepositoryMakeWorkingTrees(backing)
 
1924
        r = self.make_repository('.')
 
1925
        r.set_make_working_trees(True)
 
1926
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1927
            request.execute('', ))
 
1928
 
 
1929
    def test_is_not_shared(self):
 
1930
        """For a repository with working trees, ('no', ) is returned."""
 
1931
        backing = self.get_transport()
 
1932
        request = smart_repo.SmartServerRepositoryMakeWorkingTrees(backing)
 
1933
        r = self.make_repository('.')
 
1934
        r.set_make_working_trees(False)
 
1935
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1936
            request.execute('', ))
 
1937
 
 
1938
 
1630
1939
class TestSmartServerRepositoryLockWrite(tests.TestCaseWithMemoryTransport):
1631
1940
 
1632
1941
    def test_lock_write_on_unlocked_repo(self):
1746
2055
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
1747
2056
 
1748
2057
 
 
2058
class TestSmartServerRepositoryGetPhysicalLockStatus(
 
2059
    tests.TestCaseWithTransport):
 
2060
 
 
2061
    def test_with_write_lock(self):
 
2062
        backing = self.get_transport()
 
2063
        repo = self.make_repository('.')
 
2064
        self.addCleanup(repo.lock_write().unlock)
 
2065
        # lock_write() doesn't necessarily actually take a physical
 
2066
        # lock out.
 
2067
        if repo.get_physical_lock_status():
 
2068
            expected = 'yes'
 
2069
        else:
 
2070
            expected = 'no'
 
2071
        request_class = smart_repo.SmartServerRepositoryGetPhysicalLockStatus
 
2072
        request = request_class(backing)
 
2073
        self.assertEqual(smart_req.SuccessfulSmartServerResponse((expected,)),
 
2074
            request.execute('', ))
 
2075
 
 
2076
    def test_without_write_lock(self):
 
2077
        backing = self.get_transport()
 
2078
        repo = self.make_repository('.')
 
2079
        self.assertEquals(False, repo.get_physical_lock_status())
 
2080
        request_class = smart_repo.SmartServerRepositoryGetPhysicalLockStatus
 
2081
        request = request_class(backing)
 
2082
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('no',)),
 
2083
            request.execute('', ))
 
2084
 
 
2085
 
1749
2086
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1750
2087
 
1751
2088
    def test_is_readonly_no(self):
1789
2126
        self.assertTrue(repo.make_working_trees())
1790
2127
 
1791
2128
 
 
2129
class TestSmartServerRepositoryGetSerializerFormat(
 
2130
    tests.TestCaseWithMemoryTransport):
 
2131
 
 
2132
    def test_get_serializer_format(self):
 
2133
        backing = self.get_transport()
 
2134
        repo = self.make_repository('.', format='2a')
 
2135
        request_class = smart_repo.SmartServerRepositoryGetSerializerFormat
 
2136
        request = request_class(backing)
 
2137
        self.assertEqual(
 
2138
            smart_req.SuccessfulSmartServerResponse(('ok', '10')),
 
2139
            request.execute(''))
 
2140
 
 
2141
 
 
2142
class TestSmartServerRepositoryWriteGroup(
 
2143
    tests.TestCaseWithMemoryTransport):
 
2144
 
 
2145
    def test_start_write_group(self):
 
2146
        backing = self.get_transport()
 
2147
        repo = self.make_repository('.')
 
2148
        lock_token = repo.lock_write().repository_token
 
2149
        self.addCleanup(repo.unlock)
 
2150
        request_class = smart_repo.SmartServerRepositoryStartWriteGroup
 
2151
        request = request_class(backing)
 
2152
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok', [])),
 
2153
            request.execute('', lock_token))
 
2154
 
 
2155
    def test_start_write_group_unsuspendable(self):
 
2156
        backing = self.get_transport()
 
2157
        repo = self.make_repository('.', format='knit')
 
2158
        lock_token = repo.lock_write().repository_token
 
2159
        self.addCleanup(repo.unlock)
 
2160
        request_class = smart_repo.SmartServerRepositoryStartWriteGroup
 
2161
        request = request_class(backing)
 
2162
        self.assertEqual(
 
2163
            smart_req.FailedSmartServerResponse(('UnsuspendableWriteGroup',)),
 
2164
            request.execute('', lock_token))
 
2165
 
 
2166
    def test_commit_write_group(self):
 
2167
        backing = self.get_transport()
 
2168
        repo = self.make_repository('.')
 
2169
        lock_token = repo.lock_write().repository_token
 
2170
        self.addCleanup(repo.unlock)
 
2171
        repo.start_write_group()
 
2172
        tokens = repo.suspend_write_group()
 
2173
        request_class = smart_repo.SmartServerRepositoryCommitWriteGroup
 
2174
        request = request_class(backing)
 
2175
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
2176
            request.execute('', lock_token, tokens))
 
2177
 
 
2178
    def test_abort_write_group(self):
 
2179
        backing = self.get_transport()
 
2180
        repo = self.make_repository('.')
 
2181
        lock_token = repo.lock_write().repository_token
 
2182
        repo.start_write_group()
 
2183
        tokens = repo.suspend_write_group()
 
2184
        self.addCleanup(repo.unlock)
 
2185
        request_class = smart_repo.SmartServerRepositoryAbortWriteGroup
 
2186
        request = request_class(backing)
 
2187
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
2188
            request.execute('', lock_token, tokens))
 
2189
 
 
2190
    def test_check_write_group(self):
 
2191
        backing = self.get_transport()
 
2192
        repo = self.make_repository('.')
 
2193
        lock_token = repo.lock_write().repository_token
 
2194
        repo.start_write_group()
 
2195
        tokens = repo.suspend_write_group()
 
2196
        self.addCleanup(repo.unlock)
 
2197
        request_class = smart_repo.SmartServerRepositoryCheckWriteGroup
 
2198
        request = request_class(backing)
 
2199
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
2200
            request.execute('', lock_token, tokens))
 
2201
 
 
2202
    def test_check_write_group_invalid(self):
 
2203
        backing = self.get_transport()
 
2204
        repo = self.make_repository('.')
 
2205
        lock_token = repo.lock_write().repository_token
 
2206
        self.addCleanup(repo.unlock)
 
2207
        request_class = smart_repo.SmartServerRepositoryCheckWriteGroup
 
2208
        request = request_class(backing)
 
2209
        self.assertEqual(smart_req.FailedSmartServerResponse(
 
2210
            ('UnresumableWriteGroup', ['random'],
 
2211
                'Malformed write group token')),
 
2212
            request.execute('', lock_token, ["random"]))
 
2213
 
 
2214
 
1792
2215
class TestSmartServerPackRepositoryAutopack(tests.TestCaseWithTransport):
1793
2216
 
1794
2217
    def make_repo_needing_autopacking(self, path='.'):
1871
2294
 
1872
2295
    def test_registered_methods(self):
1873
2296
        """Test that known methods are registered to the correct object."""
 
2297
        self.assertHandlerEqual('Branch.break_lock',
 
2298
            smart_branch.SmartServerBranchBreakLock)
1874
2299
        self.assertHandlerEqual('Branch.get_config_file',
1875
2300
            smart_branch.SmartServerBranchGetConfigFile)
 
2301
        self.assertHandlerEqual('Branch.put_config_file',
 
2302
            smart_branch.SmartServerBranchPutConfigFile)
1876
2303
        self.assertHandlerEqual('Branch.get_parent',
1877
2304
            smart_branch.SmartServerBranchGetParent)
 
2305
        self.assertHandlerEqual('Branch.get_physical_lock_status',
 
2306
            smart_branch.SmartServerBranchRequestGetPhysicalLockStatus)
1878
2307
        self.assertHandlerEqual('Branch.get_tags_bytes',
1879
2308
            smart_branch.SmartServerBranchGetTagsBytes)
1880
2309
        self.assertHandlerEqual('Branch.lock_write',
1883
2312
            smart_branch.SmartServerBranchRequestLastRevisionInfo)
1884
2313
        self.assertHandlerEqual('Branch.revision_history',
1885
2314
            smart_branch.SmartServerRequestRevisionHistory)
 
2315
        self.assertHandlerEqual('Branch.revision_id_to_revno',
 
2316
            smart_branch.SmartServerBranchRequestRevisionIdToRevno)
1886
2317
        self.assertHandlerEqual('Branch.set_config_option',
1887
2318
            smart_branch.SmartServerBranchRequestSetConfigOption)
1888
2319
        self.assertHandlerEqual('Branch.set_last_revision',
1895
2326
            smart_branch.SmartServerBranchRequestSetParentLocation)
1896
2327
        self.assertHandlerEqual('Branch.unlock',
1897
2328
            smart_branch.SmartServerBranchRequestUnlock)
 
2329
        self.assertHandlerEqual('BzrDir.destroy_branch',
 
2330
            smart_dir.SmartServerBzrDirRequestDestroyBranch)
1898
2331
        self.assertHandlerEqual('BzrDir.find_repository',
1899
2332
            smart_dir.SmartServerRequestFindRepositoryV1)
1900
2333
        self.assertHandlerEqual('BzrDir.find_repositoryV2',
1915
2348
            smart_dir.SmartServerRequestOpenBranchV3)
1916
2349
        self.assertHandlerEqual('PackRepository.autopack',
1917
2350
            smart_packrepo.SmartServerPackRepositoryAutopack)
 
2351
        self.assertHandlerEqual('Repository.all_revision_ids',
 
2352
            smart_repo.SmartServerRepositoryAllRevisionIds)
 
2353
        self.assertHandlerEqual('Repository.break_lock',
 
2354
            smart_repo.SmartServerRepositoryBreakLock)
1918
2355
        self.assertHandlerEqual('Repository.gather_stats',
1919
2356
            smart_repo.SmartServerRepositoryGatherStats)
1920
2357
        self.assertHandlerEqual('Repository.get_parent_map',
1921
2358
            smart_repo.SmartServerRepositoryGetParentMap)
 
2359
        self.assertHandlerEqual('Repository.get_physical_lock_status',
 
2360
            smart_repo.SmartServerRepositoryGetPhysicalLockStatus)
1922
2361
        self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1923
2362
            smart_repo.SmartServerRepositoryGetRevIdForRevno)
1924
2363
        self.assertHandlerEqual('Repository.get_revision_graph',
1937
2376
            smart_repo.SmartServerRepositoryIsShared)
1938
2377
        self.assertHandlerEqual('Repository.lock_write',
1939
2378
            smart_repo.SmartServerRepositoryLockWrite)
 
2379
        self.assertHandlerEqual('Repository.make_working_trees',
 
2380
            smart_repo.SmartServerRepositoryMakeWorkingTrees)
1940
2381
        self.assertHandlerEqual('Repository.tarball',
1941
2382
            smart_repo.SmartServerRepositoryTarball)
1942
2383
        self.assertHandlerEqual('Repository.unlock',
1943
2384
            smart_repo.SmartServerRepositoryUnlock)
 
2385
        self.assertHandlerEqual('Repository.start_write_group',
 
2386
            smart_repo.SmartServerRepositoryStartWriteGroup)
 
2387
        self.assertHandlerEqual('Repository.check_write_group',
 
2388
            smart_repo.SmartServerRepositoryCheckWriteGroup)
 
2389
        self.assertHandlerEqual('Repository.commit_write_group',
 
2390
            smart_repo.SmartServerRepositoryCommitWriteGroup)
 
2391
        self.assertHandlerEqual('Repository.abort_write_group',
 
2392
            smart_repo.SmartServerRepositoryAbortWriteGroup)
 
2393
        self.assertHandlerEqual('VersionedFileRepository.get_serializer_format',
 
2394
            smart_repo.SmartServerRepositoryGetSerializerFormat)
1944
2395
        self.assertHandlerEqual('Transport.is_readonly',
1945
2396
            smart_req.SmartServerIsReadonly)
1946
2397