/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-03-02 03:38:07 UTC
  • mto: This revision was merged to the branch mainline in revision 4067.
  • Revision ID: robertc@robertcollins.net-20090302033807-af1b7awmfueyawts
Streaming fetch from remote servers.

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, 2007 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
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for the smart wire/domain protocol.
18
18
 
29
29
import tarfile
30
30
 
31
31
from bzrlib import (
32
 
    bencode,
33
 
    branch as _mod_branch,
34
32
    bzrdir,
35
33
    errors,
36
34
    pack,
 
35
    smart,
37
36
    tests,
38
 
    transport,
39
37
    urlutils,
40
 
    versionedfile,
41
 
    )
42
 
from bzrlib.smart import (
43
 
    branch as smart_branch,
44
 
    bzrdir as smart_dir,
45
 
    repository as smart_repo,
46
 
    packrepository as smart_packrepo,
47
 
    request as smart_req,
48
 
    server,
49
 
    vfs,
50
 
    )
51
 
from bzrlib.tests import test_server
52
 
from bzrlib.transport import (
53
 
    chroot,
54
 
    memory,
55
 
    )
 
38
    )
 
39
from bzrlib.branch import Branch, BranchReferenceFormat
 
40
import bzrlib.smart.branch
 
41
import bzrlib.smart.bzrdir
 
42
import bzrlib.smart.repository
 
43
from bzrlib.smart.request import (
 
44
    FailedSmartServerResponse,
 
45
    SmartServerRequest,
 
46
    SmartServerResponse,
 
47
    SuccessfulSmartServerResponse,
 
48
    )
 
49
from bzrlib.tests import (
 
50
    iter_suite_tests,
 
51
    split_suite_by_re,
 
52
    TestScenarioApplier,
 
53
    )
 
54
from bzrlib.transport import chroot, get_transport
 
55
from bzrlib.util import bencode
56
56
 
57
57
 
58
58
def load_tests(standard_tests, module, loader):
59
59
    """Multiply tests version and protocol consistency."""
60
60
    # FindRepository tests.
61
 
    scenarios = [
 
61
    bzrdir_mod = bzrlib.smart.bzrdir
 
62
    applier = TestScenarioApplier()
 
63
    applier.scenarios = [
62
64
        ("find_repository", {
63
 
            "_request_class": smart_dir.SmartServerRequestFindRepositoryV1}),
 
65
            "_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV1}),
64
66
        ("find_repositoryV2", {
65
 
            "_request_class": smart_dir.SmartServerRequestFindRepositoryV2}),
 
67
            "_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV2}),
66
68
        ("find_repositoryV3", {
67
 
            "_request_class": smart_dir.SmartServerRequestFindRepositoryV3}),
 
69
            "_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV3}),
68
70
        ]
69
 
    to_adapt, result = tests.split_suite_by_re(standard_tests,
 
71
    to_adapt, result = split_suite_by_re(standard_tests,
70
72
        "TestSmartServerRequestFindRepository")
71
 
    v2_only, v1_and_2 = tests.split_suite_by_re(to_adapt,
 
73
    v2_only, v1_and_2 = split_suite_by_re(to_adapt,
72
74
        "_v2")
73
 
    tests.multiply_tests(v1_and_2, scenarios, result)
74
 
    # The first scenario is only applicable to v1 protocols, it is deleted
75
 
    # since.
76
 
    tests.multiply_tests(v2_only, scenarios[1:], result)
 
75
    for test in iter_suite_tests(v1_and_2):
 
76
        result.addTests(applier.adapt(test))
 
77
    del applier.scenarios[0]
 
78
    for test in iter_suite_tests(v2_only):
 
79
        result.addTests(applier.adapt(test))
77
80
    return result
78
81
 
79
82
 
80
83
class TestCaseWithChrootedTransport(tests.TestCaseWithTransport):
81
84
 
82
85
    def setUp(self):
83
 
        self.vfs_transport_factory = memory.MemoryServer
84
86
        tests.TestCaseWithTransport.setUp(self)
85
87
        self._chroot_server = None
86
88
 
88
90
        if self._chroot_server is None:
89
91
            backing_transport = tests.TestCaseWithTransport.get_transport(self)
90
92
            self._chroot_server = chroot.ChrootServer(backing_transport)
91
 
            self.start_server(self._chroot_server)
92
 
        t = transport.get_transport(self._chroot_server.get_url())
 
93
            self._chroot_server.setUp()
 
94
            self.addCleanup(self._chroot_server.tearDown)
 
95
        t = get_transport(self._chroot_server.get_url())
93
96
        if relpath is not None:
94
97
            t = t.clone(relpath)
95
98
        return t
96
99
 
97
100
 
98
 
class TestCaseWithSmartMedium(tests.TestCaseWithMemoryTransport):
 
101
class TestCaseWithSmartMedium(tests.TestCaseWithTransport):
99
102
 
100
103
    def setUp(self):
101
104
        super(TestCaseWithSmartMedium, self).setUp()
106
109
        self.transport_server = self.make_transport_server
107
110
 
108
111
    def make_transport_server(self):
109
 
        return test_server.SmartTCPServer_for_testing('-' + self.id())
 
112
        return smart.server.SmartTCPServer_for_testing('-' + self.id())
110
113
 
111
114
    def get_smart_medium(self):
112
115
        """Get a smart medium to use in tests."""
113
116
        return self.get_transport().get_smart_medium()
114
117
 
115
118
 
116
 
class TestByteStreamToStream(tests.TestCase):
117
 
 
118
 
    def test_repeated_substreams_same_kind_are_one_stream(self):
119
 
        # Make a stream - an iterable of bytestrings.
120
 
        stream = [('text', [versionedfile.FulltextContentFactory(('k1',), None,
121
 
            None, 'foo')]),('text', [
122
 
            versionedfile.FulltextContentFactory(('k2',), None, None, 'bar')])]
123
 
        fmt = bzrdir.format_registry.get('pack-0.92')().repository_format
124
 
        bytes = smart_repo._stream_to_byte_stream(stream, fmt)
125
 
        streams = []
126
 
        # Iterate the resulting iterable; checking that we get only one stream
127
 
        # out.
128
 
        fmt, stream = smart_repo._byte_stream_to_stream(bytes)
129
 
        for kind, substream in stream:
130
 
            streams.append((kind, list(substream)))
131
 
        self.assertLength(1, streams)
132
 
        self.assertLength(2, streams[0][1])
133
 
 
134
 
 
135
119
class TestSmartServerResponse(tests.TestCase):
136
120
 
137
121
    def test__eq__(self):
138
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )),
139
 
            smart_req.SmartServerResponse(('ok', )))
140
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'body'),
141
 
            smart_req.SmartServerResponse(('ok', ), 'body'))
142
 
        self.assertNotEqual(smart_req.SmartServerResponse(('ok', )),
143
 
            smart_req.SmartServerResponse(('notok', )))
144
 
        self.assertNotEqual(smart_req.SmartServerResponse(('ok', ), 'body'),
145
 
            smart_req.SmartServerResponse(('ok', )))
 
122
        self.assertEqual(SmartServerResponse(('ok', )),
 
123
            SmartServerResponse(('ok', )))
 
124
        self.assertEqual(SmartServerResponse(('ok', ), 'body'),
 
125
            SmartServerResponse(('ok', ), 'body'))
 
126
        self.assertNotEqual(SmartServerResponse(('ok', )),
 
127
            SmartServerResponse(('notok', )))
 
128
        self.assertNotEqual(SmartServerResponse(('ok', ), 'body'),
 
129
            SmartServerResponse(('ok', )))
146
130
        self.assertNotEqual(None,
147
 
            smart_req.SmartServerResponse(('ok', )))
 
131
            SmartServerResponse(('ok', )))
148
132
 
149
133
    def test__str__(self):
150
134
        """SmartServerResponses can be stringified."""
151
135
        self.assertEqual(
152
136
            "<SuccessfulSmartServerResponse args=('args',) body='body'>",
153
 
            str(smart_req.SuccessfulSmartServerResponse(('args',), 'body')))
 
137
            str(SuccessfulSmartServerResponse(('args',), 'body')))
154
138
        self.assertEqual(
155
139
            "<FailedSmartServerResponse args=('args',) body='body'>",
156
 
            str(smart_req.FailedSmartServerResponse(('args',), 'body')))
 
140
            str(FailedSmartServerResponse(('args',), 'body')))
157
141
 
158
142
 
159
143
class TestSmartServerRequest(tests.TestCaseWithMemoryTransport):
160
144
 
161
145
    def test_translate_client_path(self):
162
146
        transport = self.get_transport()
163
 
        request = smart_req.SmartServerRequest(transport, 'foo/')
 
147
        request = SmartServerRequest(transport, 'foo/')
164
148
        self.assertEqual('./', request.translate_client_path('foo/'))
165
149
        self.assertRaises(
166
150
            errors.InvalidURLJoin, request.translate_client_path, 'foo/..')
169
153
        self.assertRaises(
170
154
            errors.PathNotChild, request.translate_client_path, 'bar/')
171
155
        self.assertEqual('./baz', request.translate_client_path('foo/baz'))
172
 
        e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'.encode('utf-8')
173
 
        self.assertEqual('./' + urlutils.escape(e_acute),
174
 
                         request.translate_client_path('foo/' + e_acute))
175
 
 
176
 
    def test_translate_client_path_vfs(self):
177
 
        """VfsRequests receive escaped paths rather than raw UTF-8."""
178
 
        transport = self.get_transport()
179
 
        request = vfs.VfsRequest(transport, 'foo/')
180
 
        e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'.encode('utf-8')
181
 
        escaped = urlutils.escape('foo/' + e_acute)
182
 
        self.assertEqual('./' + urlutils.escape(e_acute),
183
 
                         request.translate_client_path(escaped))
184
156
 
185
157
    def test_transport_from_client_path(self):
186
158
        transport = self.get_transport()
187
 
        request = smart_req.SmartServerRequest(transport, 'foo/')
 
159
        request = SmartServerRequest(transport, 'foo/')
188
160
        self.assertEqual(
189
161
            transport.base,
190
162
            request.transport_from_client_path('foo/').base)
191
163
 
192
164
 
193
 
class TestSmartServerBzrDirRequestCloningMetaDir(
194
 
    tests.TestCaseWithMemoryTransport):
195
 
    """Tests for BzrDir.cloning_metadir."""
196
 
 
197
 
    def test_cloning_metadir(self):
198
 
        """When there is a bzrdir present, the call succeeds."""
199
 
        backing = self.get_transport()
200
 
        dir = self.make_bzrdir('.')
201
 
        local_result = dir.cloning_metadir()
202
 
        request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
203
 
        request = request_class(backing)
204
 
        expected = smart_req.SuccessfulSmartServerResponse(
205
 
            (local_result.network_name(),
206
 
            local_result.repository_format.network_name(),
207
 
            ('branch', local_result.get_branch_format().network_name())))
208
 
        self.assertEqual(expected, request.execute('', 'False'))
209
 
 
210
 
    def test_cloning_metadir_reference(self):
211
 
        """The request fails when bzrdir contains a branch reference."""
212
 
        backing = self.get_transport()
213
 
        referenced_branch = self.make_branch('referenced')
214
 
        dir = self.make_bzrdir('.')
215
 
        local_result = dir.cloning_metadir()
216
 
        reference = _mod_branch.BranchReferenceFormat().initialize(
217
 
            dir, target_branch=referenced_branch)
218
 
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(dir)
219
 
        # The server shouldn't try to follow the branch reference, so it's fine
220
 
        # if the referenced branch isn't reachable.
221
 
        backing.rename('referenced', 'moved')
222
 
        request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
223
 
        request = request_class(backing)
224
 
        expected = smart_req.FailedSmartServerResponse(('BranchReference',))
225
 
        self.assertEqual(expected, request.execute('', 'False'))
226
 
 
227
 
 
228
165
class TestSmartServerRequestCreateRepository(tests.TestCaseWithMemoryTransport):
229
166
    """Tests for BzrDir.create_repository."""
230
167
 
232
169
        """When there is a bzrdir present, the call succeeds."""
233
170
        backing = self.get_transport()
234
171
        self.make_bzrdir('.')
235
 
        request_class = smart_dir.SmartServerRequestCreateRepository
 
172
        request_class = bzrlib.smart.bzrdir.SmartServerRequestCreateRepository
236
173
        request = request_class(backing)
237
 
        reference_bzrdir_format = bzrdir.format_registry.get('pack-0.92')()
 
174
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
238
175
        reference_format = reference_bzrdir_format.repository_format
239
176
        network_name = reference_format.network_name()
240
 
        expected = smart_req.SuccessfulSmartServerResponse(
 
177
        expected = SuccessfulSmartServerResponse(
241
178
            ('ok', 'no', 'no', 'no', network_name))
242
179
        self.assertEqual(expected, request.execute('', network_name, 'True'))
243
180
 
250
187
        backing = self.get_transport()
251
188
        request = self._request_class(backing)
252
189
        self.make_bzrdir('.')
253
 
        self.assertEqual(smart_req.SmartServerResponse(('norepository', )),
 
190
        self.assertEqual(SmartServerResponse(('norepository', )),
254
191
            request.execute(''))
255
192
 
256
193
    def test_nonshared_repository(self):
262
199
        result = self._make_repository_and_result()
263
200
        self.assertEqual(result, request.execute(''))
264
201
        self.make_bzrdir('subdir')
265
 
        self.assertEqual(smart_req.SmartServerResponse(('norepository', )),
 
202
        self.assertEqual(SmartServerResponse(('norepository', )),
266
203
            request.execute('subdir'))
267
204
 
268
205
    def _make_repository_and_result(self, shared=False, format=None):
279
216
            subtrees = 'yes'
280
217
        else:
281
218
            subtrees = 'no'
282
 
        if repo._format.supports_external_lookups:
283
 
            external = 'yes'
284
 
        else:
285
 
            external = 'no'
286
 
        if (smart_dir.SmartServerRequestFindRepositoryV3 ==
 
219
        if (smart.bzrdir.SmartServerRequestFindRepositoryV3 ==
287
220
            self._request_class):
288
 
            return smart_req.SuccessfulSmartServerResponse(
289
 
                ('ok', '', rich_root, subtrees, external,
 
221
            return SuccessfulSmartServerResponse(
 
222
                ('ok', '', rich_root, subtrees, 'no',
290
223
                 repo._format.network_name()))
291
 
        elif (smart_dir.SmartServerRequestFindRepositoryV2 ==
 
224
        elif (smart.bzrdir.SmartServerRequestFindRepositoryV2 ==
292
225
            self._request_class):
293
226
            # All tests so far are on formats, and for non-external
294
227
            # repositories.
295
 
            return smart_req.SuccessfulSmartServerResponse(
296
 
                ('ok', '', rich_root, subtrees, external))
 
228
            return SuccessfulSmartServerResponse(
 
229
                ('ok', '', rich_root, subtrees, 'no'))
297
230
        else:
298
 
            return smart_req.SuccessfulSmartServerResponse(
299
 
                ('ok', '', rich_root, subtrees))
 
231
            return SuccessfulSmartServerResponse(('ok', '', rich_root, subtrees))
300
232
 
301
233
    def test_shared_repository(self):
302
234
        """When there is a shared repository, we get 'ok', 'relpath-to-repo'."""
305
237
        result = self._make_repository_and_result(shared=True)
306
238
        self.assertEqual(result, request.execute(''))
307
239
        self.make_bzrdir('subdir')
308
 
        result2 = smart_req.SmartServerResponse(
309
 
            result.args[0:1] + ('..', ) + result.args[2:])
 
240
        result2 = SmartServerResponse(result.args[0:1] + ('..', ) + result.args[2:])
310
241
        self.assertEqual(result2,
311
242
            request.execute('subdir'))
312
243
        self.make_bzrdir('subdir/deeper')
313
 
        result3 = smart_req.SmartServerResponse(
314
 
            result.args[0:1] + ('../..', ) + result.args[2:])
 
244
        result3 = SmartServerResponse(result.args[0:1] + ('../..', ) + result.args[2:])
315
245
        self.assertEqual(result3,
316
246
            request.execute('subdir/deeper'))
317
247
 
319
249
        """Test for the format attributes for rich root and subtree support."""
320
250
        backing = self.get_transport()
321
251
        request = self._request_class(backing)
322
 
        result = self._make_repository_and_result(
323
 
            format='dirstate-with-subtree')
 
252
        result = self._make_repository_and_result(format='dirstate-with-subtree')
324
253
        # check the test will be valid
325
254
        self.assertEqual('yes', result.args[2])
326
255
        self.assertEqual('yes', result.args[3])
330
259
        """Test for the supports_external_lookups attribute."""
331
260
        backing = self.get_transport()
332
261
        request = self._request_class(backing)
333
 
        result = self._make_repository_and_result(
334
 
            format='dirstate-with-subtree')
 
262
        result = self._make_repository_and_result(format='dirstate-with-subtree')
335
263
        # check the test will be valid
336
264
        self.assertEqual('no', result.args[4])
337
265
        self.assertEqual(result, request.execute(''))
338
266
 
339
267
 
340
 
class TestSmartServerBzrDirRequestGetConfigFile(
341
 
    tests.TestCaseWithMemoryTransport):
342
 
    """Tests for BzrDir.get_config_file."""
343
 
 
344
 
    def test_present(self):
345
 
        backing = self.get_transport()
346
 
        dir = self.make_bzrdir('.')
347
 
        dir.get_config().set_default_stack_on("/")
348
 
        local_result = dir._get_config()._get_config_file().read()
349
 
        request_class = smart_dir.SmartServerBzrDirRequestConfigFile
350
 
        request = request_class(backing)
351
 
        expected = smart_req.SuccessfulSmartServerResponse((), local_result)
352
 
        self.assertEqual(expected, request.execute(''))
353
 
 
354
 
    def test_missing(self):
355
 
        backing = self.get_transport()
356
 
        dir = self.make_bzrdir('.')
357
 
        request_class = smart_dir.SmartServerBzrDirRequestConfigFile
358
 
        request = request_class(backing)
359
 
        expected = smart_req.SuccessfulSmartServerResponse((), '')
360
 
        self.assertEqual(expected, request.execute(''))
361
 
 
362
 
 
363
268
class TestSmartServerRequestInitializeBzrDir(tests.TestCaseWithMemoryTransport):
364
269
 
365
270
    def test_empty_dir(self):
366
271
        """Initializing an empty dir should succeed and do it."""
367
272
        backing = self.get_transport()
368
 
        request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
369
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )),
 
273
        request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
 
274
        self.assertEqual(SmartServerResponse(('ok', )),
370
275
            request.execute(''))
371
276
        made_dir = bzrdir.BzrDir.open_from_transport(backing)
372
277
        # no branch, tree or repository is expected with the current
378
283
    def test_missing_dir(self):
379
284
        """Initializing a missing directory should fail like the bzrdir api."""
380
285
        backing = self.get_transport()
381
 
        request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
 
286
        request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
382
287
        self.assertRaises(errors.NoSuchFile,
383
288
            request.execute, 'subdir')
384
289
 
385
290
    def test_initialized_dir(self):
386
291
        """Initializing an extant bzrdir should fail like the bzrdir api."""
387
292
        backing = self.get_transport()
388
 
        request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
 
293
        request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
389
294
        self.make_bzrdir('subdir')
390
295
        self.assertRaises(errors.FileExists,
391
296
            request.execute, 'subdir')
392
297
 
393
298
 
394
 
class TestSmartServerRequestBzrDirInitializeEx(
395
 
    tests.TestCaseWithMemoryTransport):
396
 
    """Basic tests for BzrDir.initialize_ex_1.16 in the smart server.
397
 
 
398
 
    The main unit tests in test_bzrdir exercise the API comprehensively.
399
 
    """
400
 
 
401
 
    def test_empty_dir(self):
402
 
        """Initializing an empty dir should succeed and do it."""
403
 
        backing = self.get_transport()
404
 
        name = self.make_bzrdir('reference')._format.network_name()
405
 
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
406
 
        self.assertEqual(
407
 
            smart_req.SmartServerResponse(('', '', '', '', '', '', name,
408
 
                                           'False', '', '', '')),
409
 
            request.execute(name, '', 'True', 'False', 'False', '', '', '', '',
410
 
                            'False'))
411
 
        made_dir = bzrdir.BzrDir.open_from_transport(backing)
412
 
        # no branch, tree or repository is expected with the current
413
 
        # default format.
414
 
        self.assertRaises(errors.NoWorkingTree, made_dir.open_workingtree)
415
 
        self.assertRaises(errors.NotBranchError, made_dir.open_branch)
416
 
        self.assertRaises(errors.NoRepositoryPresent, made_dir.open_repository)
417
 
 
418
 
    def test_missing_dir(self):
419
 
        """Initializing a missing directory should fail like the bzrdir api."""
420
 
        backing = self.get_transport()
421
 
        name = self.make_bzrdir('reference')._format.network_name()
422
 
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
423
 
        self.assertRaises(errors.NoSuchFile, request.execute, name,
424
 
            'subdir/dir', 'False', 'False', 'False', '', '', '', '', 'False')
425
 
 
426
 
    def test_initialized_dir(self):
427
 
        """Initializing an extant directory should fail like the bzrdir api."""
428
 
        backing = self.get_transport()
429
 
        name = self.make_bzrdir('reference')._format.network_name()
430
 
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
431
 
        self.make_bzrdir('subdir')
432
 
        self.assertRaises(errors.FileExists, request.execute, name, 'subdir',
433
 
            'False', 'False', 'False', '', '', '', '', 'False')
434
 
 
435
 
 
436
 
class TestSmartServerRequestOpenBzrDir(tests.TestCaseWithMemoryTransport):
437
 
 
438
 
    def test_no_directory(self):
439
 
        backing = self.get_transport()
440
 
        request = smart_dir.SmartServerRequestOpenBzrDir(backing)
441
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
442
 
            request.execute('does-not-exist'))
443
 
 
444
 
    def test_empty_directory(self):
445
 
        backing = self.get_transport()
446
 
        backing.mkdir('empty')
447
 
        request = smart_dir.SmartServerRequestOpenBzrDir(backing)
448
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
449
 
            request.execute('empty'))
450
 
 
451
 
    def test_outside_root_client_path(self):
452
 
        backing = self.get_transport()
453
 
        request = smart_dir.SmartServerRequestOpenBzrDir(backing,
454
 
            root_client_path='root')
455
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
456
 
            request.execute('not-root'))
457
 
 
458
 
 
459
 
class TestSmartServerRequestOpenBzrDir_2_1(tests.TestCaseWithMemoryTransport):
460
 
 
461
 
    def test_no_directory(self):
462
 
        backing = self.get_transport()
463
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
464
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
465
 
            request.execute('does-not-exist'))
466
 
 
467
 
    def test_empty_directory(self):
468
 
        backing = self.get_transport()
469
 
        backing.mkdir('empty')
470
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
471
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
472
 
            request.execute('empty'))
473
 
 
474
 
    def test_present_without_workingtree(self):
475
 
        backing = self.get_transport()
476
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
477
 
        self.make_bzrdir('.')
478
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', 'no')),
479
 
            request.execute(''))
480
 
 
481
 
    def test_outside_root_client_path(self):
482
 
        backing = self.get_transport()
483
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing,
484
 
            root_client_path='root')
485
 
        self.assertEqual(smart_req.SmartServerResponse(('no',)),
486
 
            request.execute('not-root'))
487
 
 
488
 
 
489
 
class TestSmartServerRequestOpenBzrDir_2_1_disk(TestCaseWithChrootedTransport):
490
 
 
491
 
    def test_present_with_workingtree(self):
492
 
        self.vfs_transport_factory = test_server.LocalURLServer
493
 
        backing = self.get_transport()
494
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
495
 
        bd = self.make_bzrdir('.')
496
 
        bd.create_repository()
497
 
        bd.create_branch()
498
 
        bd.create_workingtree()
499
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', 'yes')),
500
 
            request.execute(''))
501
 
 
502
 
 
503
299
class TestSmartServerRequestOpenBranch(TestCaseWithChrootedTransport):
504
300
 
505
301
    def test_no_branch(self):
506
302
        """When there is no branch, ('nobranch', ) is returned."""
507
303
        backing = self.get_transport()
508
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
 
304
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
509
305
        self.make_bzrdir('.')
510
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
 
306
        self.assertEqual(SmartServerResponse(('nobranch', )),
511
307
            request.execute(''))
512
308
 
513
309
    def test_branch(self):
514
310
        """When there is a branch, 'ok' is returned."""
515
311
        backing = self.get_transport()
516
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
 
312
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
517
313
        self.make_branch('.')
518
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', '')),
 
314
        self.assertEqual(SmartServerResponse(('ok', '')),
519
315
            request.execute(''))
520
316
 
521
317
    def test_branch_reference(self):
522
318
        """When there is a branch reference, the reference URL is returned."""
523
 
        self.vfs_transport_factory = test_server.LocalURLServer
524
319
        backing = self.get_transport()
525
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
 
320
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
526
321
        branch = self.make_branch('branch')
527
322
        checkout = branch.create_checkout('reference',lightweight=True)
528
 
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
529
 
            checkout.bzrdir)
 
323
        reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
530
324
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
531
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', reference_url)),
 
325
        self.assertEqual(SmartServerResponse(('ok', reference_url)),
532
326
            request.execute('reference'))
533
327
 
534
 
    def test_notification_on_branch_from_repository(self):
535
 
        """When there is a repository, the error should return details."""
536
 
        backing = self.get_transport()
537
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
538
 
        repo = self.make_repository('.')
539
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
540
 
            request.execute(''))
541
 
 
542
 
 
543
 
class TestSmartServerRequestOpenBranchV2(TestCaseWithChrootedTransport):
544
 
 
545
 
    def test_no_branch(self):
546
 
        """When there is no branch, ('nobranch', ) is returned."""
547
 
        backing = self.get_transport()
548
 
        self.make_bzrdir('.')
549
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
550
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
551
 
            request.execute(''))
552
 
 
553
 
    def test_branch(self):
554
 
        """When there is a branch, 'ok' is returned."""
555
 
        backing = self.get_transport()
556
 
        expected = self.make_branch('.')._format.network_name()
557
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
558
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
559
 
                ('branch', expected)),
560
 
                         request.execute(''))
561
 
 
562
 
    def test_branch_reference(self):
563
 
        """When there is a branch reference, the reference URL is returned."""
564
 
        self.vfs_transport_factory = test_server.LocalURLServer
565
 
        backing = self.get_transport()
566
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
567
 
        branch = self.make_branch('branch')
568
 
        checkout = branch.create_checkout('reference',lightweight=True)
569
 
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
570
 
            checkout.bzrdir)
571
 
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
572
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
573
 
                ('ref', reference_url)),
574
 
                         request.execute('reference'))
575
 
 
576
 
    def test_stacked_branch(self):
577
 
        """Opening a stacked branch does not open the stacked-on branch."""
578
 
        trunk = self.make_branch('trunk')
579
 
        feature = self.make_branch('feature')
580
 
        feature.set_stacked_on_url(trunk.base)
581
 
        opened_branches = []
582
 
        _mod_branch.Branch.hooks.install_named_hook(
583
 
            'open', opened_branches.append, None)
584
 
        backing = self.get_transport()
585
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
586
 
        request.setup_jail()
587
 
        try:
588
 
            response = request.execute('feature')
589
 
        finally:
590
 
            request.teardown_jail()
591
 
        expected_format = feature._format.network_name()
592
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
593
 
                ('branch', expected_format)),
594
 
                         response)
595
 
        self.assertLength(1, opened_branches)
596
 
 
597
 
    def test_notification_on_branch_from_repository(self):
598
 
        """When there is a repository, the error should return details."""
599
 
        backing = self.get_transport()
600
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
601
 
        repo = self.make_repository('.')
602
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
603
 
            request.execute(''))
604
 
 
605
 
 
606
 
class TestSmartServerRequestOpenBranchV3(TestCaseWithChrootedTransport):
607
 
 
608
 
    def test_no_branch(self):
609
 
        """When there is no branch, ('nobranch', ) is returned."""
610
 
        backing = self.get_transport()
611
 
        self.make_bzrdir('.')
612
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
613
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
614
 
            request.execute(''))
615
 
 
616
 
    def test_branch(self):
617
 
        """When there is a branch, 'ok' is returned."""
618
 
        backing = self.get_transport()
619
 
        expected = self.make_branch('.')._format.network_name()
620
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
621
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
622
 
                ('branch', expected)),
623
 
                         request.execute(''))
624
 
 
625
 
    def test_branch_reference(self):
626
 
        """When there is a branch reference, the reference URL is returned."""
627
 
        self.vfs_transport_factory = test_server.LocalURLServer
628
 
        backing = self.get_transport()
629
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
630
 
        branch = self.make_branch('branch')
631
 
        checkout = branch.create_checkout('reference',lightweight=True)
632
 
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
633
 
            checkout.bzrdir)
634
 
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
635
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
636
 
                ('ref', reference_url)),
637
 
                         request.execute('reference'))
638
 
 
639
 
    def test_stacked_branch(self):
640
 
        """Opening a stacked branch does not open the stacked-on branch."""
641
 
        trunk = self.make_branch('trunk')
642
 
        feature = self.make_branch('feature')
643
 
        feature.set_stacked_on_url(trunk.base)
644
 
        opened_branches = []
645
 
        _mod_branch.Branch.hooks.install_named_hook(
646
 
            'open', opened_branches.append, None)
647
 
        backing = self.get_transport()
648
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
649
 
        request.setup_jail()
650
 
        try:
651
 
            response = request.execute('feature')
652
 
        finally:
653
 
            request.teardown_jail()
654
 
        expected_format = feature._format.network_name()
655
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
656
 
                ('branch', expected_format)),
657
 
                         response)
658
 
        self.assertLength(1, opened_branches)
659
 
 
660
 
    def test_notification_on_branch_from_repository(self):
661
 
        """When there is a repository, the error should return details."""
662
 
        backing = self.get_transport()
663
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
664
 
        repo = self.make_repository('.')
665
 
        self.assertEqual(smart_req.SmartServerResponse(
666
 
                ('nobranch', 'location is a repository')),
667
 
                         request.execute(''))
668
 
 
669
328
 
670
329
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
671
330
 
672
331
    def test_empty(self):
673
332
        """For an empty branch, the body is empty."""
674
333
        backing = self.get_transport()
675
 
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
 
334
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
676
335
        self.make_branch('.')
677
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), ''),
 
336
        self.assertEqual(SmartServerResponse(('ok', ), ''),
678
337
            request.execute(''))
679
338
 
680
339
    def test_not_empty(self):
681
340
        """For a non-empty branch, the body is empty."""
682
341
        backing = self.get_transport()
683
 
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
 
342
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
684
343
        tree = self.make_branch_and_memory_tree('.')
685
344
        tree.lock_write()
686
345
        tree.add('')
688
347
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
689
348
        tree.unlock()
690
349
        self.assertEqual(
691
 
            smart_req.SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
 
350
            SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
692
351
            request.execute(''))
693
352
 
694
353
 
697
356
    def test_no_branch(self):
698
357
        """When there is a bzrdir and no branch, NotBranchError is raised."""
699
358
        backing = self.get_transport()
700
 
        request = smart_branch.SmartServerBranchRequest(backing)
 
359
        request = smart.branch.SmartServerBranchRequest(backing)
701
360
        self.make_bzrdir('.')
702
361
        self.assertRaises(errors.NotBranchError,
703
362
            request.execute, '')
705
364
    def test_branch_reference(self):
706
365
        """When there is a branch reference, NotBranchError is raised."""
707
366
        backing = self.get_transport()
708
 
        request = smart_branch.SmartServerBranchRequest(backing)
 
367
        request = smart.branch.SmartServerBranchRequest(backing)
709
368
        branch = self.make_branch('branch')
710
369
        checkout = branch.create_checkout('reference',lightweight=True)
711
370
        self.assertRaises(errors.NotBranchError,
712
371
            request.execute, 'checkout')
713
372
 
714
373
 
715
 
class TestSmartServerBranchRequestLastRevisionInfo(
716
 
    tests.TestCaseWithMemoryTransport):
 
374
class TestSmartServerBranchRequestLastRevisionInfo(tests.TestCaseWithMemoryTransport):
717
375
 
718
376
    def test_empty(self):
719
377
        """For an empty branch, the result is ('ok', '0', 'null:')."""
720
378
        backing = self.get_transport()
721
 
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
379
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
722
380
        self.make_branch('.')
723
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', '0', 'null:')),
 
381
        self.assertEqual(SmartServerResponse(('ok', '0', 'null:')),
724
382
            request.execute(''))
725
383
 
726
384
    def test_not_empty(self):
727
385
        """For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
728
386
        backing = self.get_transport()
729
 
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
387
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
730
388
        tree = self.make_branch_and_memory_tree('.')
731
389
        tree.lock_write()
732
390
        tree.add('')
735
393
        r2 = tree.commit('2nd commit', rev_id=rev_id_utf8)
736
394
        tree.unlock()
737
395
        self.assertEqual(
738
 
            smart_req.SmartServerResponse(('ok', '2', rev_id_utf8)),
 
396
            SmartServerResponse(('ok', '2', rev_id_utf8)),
739
397
            request.execute(''))
740
398
 
741
399
 
742
 
class TestSmartServerBranchRequestGetConfigFile(
743
 
    tests.TestCaseWithMemoryTransport):
 
400
class TestSmartServerBranchRequestGetConfigFile(tests.TestCaseWithMemoryTransport):
744
401
 
745
402
    def test_default(self):
746
403
        """With no file, we get empty content."""
747
404
        backing = self.get_transport()
748
 
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
 
405
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
749
406
        branch = self.make_branch('.')
750
407
        # there should be no file by default
751
408
        content = ''
752
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), content),
 
409
        self.assertEqual(SmartServerResponse(('ok', ), content),
753
410
            request.execute(''))
754
411
 
755
412
    def test_with_content(self):
757
414
        # branch.control_files.get('branch.conf') for now - in the future it may
758
415
        # perform more complex processing.
759
416
        backing = self.get_transport()
760
 
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
 
417
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
761
418
        branch = self.make_branch('.')
762
419
        branch._transport.put_bytes('branch.conf', 'foo bar baz')
763
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'foo bar baz'),
 
420
        self.assertEqual(SmartServerResponse(('ok', ), 'foo bar baz'),
764
421
            request.execute(''))
765
422
 
766
423
 
767
 
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
768
 
 
769
 
    def get_lock_tokens(self, branch):
770
 
        branch_token = branch.lock_write()
771
 
        repo_token = branch.repository.lock_write()
772
 
        branch.repository.unlock()
773
 
        return branch_token, repo_token
774
 
 
775
 
 
776
 
class TestSmartServerBranchRequestSetConfigOption(TestLockedBranch):
777
 
 
778
 
    def test_value_name(self):
779
 
        branch = self.make_branch('.')
780
 
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
781
 
            branch.bzrdir.root_transport)
782
 
        branch_token, repo_token = self.get_lock_tokens(branch)
783
 
        config = branch._get_config()
784
 
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
785
 
            '')
786
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
787
 
        self.assertEqual('bar', config.get_option('foo'))
788
 
        # Cleanup
789
 
        branch.unlock()
790
 
 
791
 
    def test_value_name_section(self):
792
 
        branch = self.make_branch('.')
793
 
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
794
 
            branch.bzrdir.root_transport)
795
 
        branch_token, repo_token = self.get_lock_tokens(branch)
796
 
        config = branch._get_config()
797
 
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
798
 
            'gam')
799
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
800
 
        self.assertEqual('bar', config.get_option('foo', 'gam'))
801
 
        # Cleanup
802
 
        branch.unlock()
803
 
 
804
 
 
805
 
class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):
806
 
    # Only called when the branch format and tags match [yay factory
807
 
    # methods] so only need to test straight forward cases.
808
 
 
809
 
    def test_set_bytes(self):
810
 
        base_branch = self.make_branch('base')
811
 
        tag_bytes = base_branch._get_tags_bytes()
812
 
        # get_lock_tokens takes out a lock.
813
 
        branch_token, repo_token = self.get_lock_tokens(base_branch)
814
 
        request = smart_branch.SmartServerBranchSetTagsBytes(
815
 
            self.get_transport())
816
 
        response = request.execute('base', branch_token, repo_token)
817
 
        self.assertEqual(None, response)
818
 
        response = request.do_chunk(tag_bytes)
819
 
        self.assertEqual(None, response)
820
 
        response = request.do_end()
821
 
        self.assertEquals(
822
 
            smart_req.SuccessfulSmartServerResponse(()), response)
823
 
        base_branch.unlock()
824
 
 
825
 
    def test_lock_failed(self):
826
 
        base_branch = self.make_branch('base')
827
 
        base_branch.lock_write()
828
 
        tag_bytes = base_branch._get_tags_bytes()
829
 
        request = smart_branch.SmartServerBranchSetTagsBytes(
830
 
            self.get_transport())
831
 
        self.assertRaises(errors.TokenMismatch, request.execute,
832
 
            'base', 'wrong token', 'wrong token')
833
 
        # The request handler will keep processing the message parts, so even
834
 
        # if the request fails immediately do_chunk and do_end are still
835
 
        # called.
836
 
        request.do_chunk(tag_bytes)
837
 
        request.do_end()
838
 
        base_branch.unlock()
839
 
 
840
 
 
841
 
 
842
 
class SetLastRevisionTestBase(TestLockedBranch):
 
424
class SetLastRevisionTestBase(tests.TestCaseWithMemoryTransport):
843
425
    """Base test case for verbs that implement set_last_revision."""
844
426
 
845
427
    def setUp(self):
849
431
        self.tree = self.make_branch_and_memory_tree('.')
850
432
 
851
433
    def lock_branch(self):
852
 
        return self.get_lock_tokens(self.tree.branch)
 
434
        b = self.tree.branch
 
435
        branch_token = b.lock_write()
 
436
        repo_token = b.repository.lock_write()
 
437
        b.repository.unlock()
 
438
        return branch_token, repo_token
853
439
 
854
440
    def unlock_branch(self):
855
441
        self.tree.branch.unlock()
863
449
 
864
450
    def assertRequestSucceeds(self, revision_id, revno):
865
451
        response = self.set_last_revision(revision_id, revno)
866
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
867
 
                         response)
 
452
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)), response)
868
453
 
869
454
 
870
455
class TestSetLastRevisionVerbMixin(object):
878
463
        """If the revision_id is not present, the verb returns NoSuchRevision.
879
464
        """
880
465
        revision_id = 'non-existent revision'
881
 
        self.assertEqual(smart_req.FailedSmartServerResponse(('NoSuchRevision',
882
 
                                                              revision_id)),
883
 
                         self.set_last_revision(revision_id, 1))
 
466
        self.assertEqual(
 
467
            FailedSmartServerResponse(('NoSuchRevision', revision_id)),
 
468
            self.set_last_revision(revision_id, 1))
884
469
 
885
470
    def make_tree_with_two_commits(self):
886
471
        self.tree.lock_write()
926
511
        rejection_message = u'rejection message\N{INTERROBANG}'
927
512
        def hook_that_rejects(params):
928
513
            raise errors.TipChangeRejected(rejection_message)
929
 
        _mod_branch.Branch.hooks.install_named_hook(
 
514
        Branch.hooks.install_named_hook(
930
515
            'pre_change_branch_tip', hook_that_rejects, None)
931
516
        self.assertEqual(
932
 
            smart_req.FailedSmartServerResponse(
 
517
            FailedSmartServerResponse(
933
518
                ('TipChangeRejected', rejection_message.encode('utf-8'))),
934
519
            self.set_last_revision('null:', 0))
935
520
 
938
523
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
939
524
    """Tests for Branch.set_last_revision verb."""
940
525
 
941
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevision
 
526
    request_class = smart.branch.SmartServerBranchRequestSetLastRevision
942
527
 
943
528
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
944
529
        return self.request.execute(
949
534
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
950
535
    """Tests for Branch.set_last_revision_info verb."""
951
536
 
952
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionInfo
 
537
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionInfo
953
538
 
954
539
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
955
540
        return self.request.execute(
966
551
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
967
552
    """Tests for Branch.set_last_revision_ex verb."""
968
553
 
969
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionEx
 
554
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionEx
970
555
 
971
556
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
972
557
        return self.request.execute(
975
560
    def assertRequestSucceeds(self, revision_id, revno):
976
561
        response = self.set_last_revision(revision_id, revno)
977
562
        self.assertEqual(
978
 
            smart_req.SuccessfulSmartServerResponse(('ok', revno, revision_id)),
 
563
            SuccessfulSmartServerResponse(('ok', revno, revision_id)),
979
564
            response)
980
565
 
981
566
    def test_branch_last_revision_info_rewind(self):
992
577
        response = self.request.execute(
993
578
            '', branch_token, repo_token, rev_id_utf8, 0, 0)
994
579
        self.assertEqual(
995
 
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
 
580
            SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
996
581
            response)
997
582
        self.assertEqual(
998
583
            (2, 'rev-2'), self.tree.branch.last_revision_info())
1002
587
        response = self.request.execute(
1003
588
            '', branch_token, repo_token, rev_id_utf8, 0, 1)
1004
589
        self.assertEqual(
1005
 
            smart_req.SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
 
590
            SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
1006
591
            response)
1007
592
        self.unlock_branch()
1008
593
        self.assertEqual(
1033
618
        """
1034
619
        self.make_branch_with_divergent_history()
1035
620
        self.assertEqual(
1036
 
            smart_req.FailedSmartServerResponse(('Diverged',)),
 
621
            FailedSmartServerResponse(('Diverged',)),
1037
622
            self.set_last_revision('child-1', 2))
1038
623
        # The branch tip was not changed.
1039
624
        self.assertEqual('child-2', self.tree.branch.last_revision())
1047
632
        response = self.request.execute(
1048
633
            '', branch_token, repo_token, 'child-1', 1, 0)
1049
634
        self.assertEqual(
1050
 
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
 
635
            SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
1051
636
            response)
1052
637
        self.unlock_branch()
1053
638
        # The branch tip was changed.
1054
639
        self.assertEqual('child-1', self.tree.branch.last_revision())
1055
640
 
1056
641
 
1057
 
class TestSmartServerBranchRequestGetParent(tests.TestCaseWithMemoryTransport):
1058
 
 
1059
 
    def test_get_parent_none(self):
1060
 
        base_branch = self.make_branch('base')
1061
 
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
1062
 
        response = request.execute('base')
1063
 
        self.assertEquals(
1064
 
            smart_req.SuccessfulSmartServerResponse(('',)), response)
1065
 
 
1066
 
    def test_get_parent_something(self):
1067
 
        base_branch = self.make_branch('base')
1068
 
        base_branch.set_parent(self.get_url('foo'))
1069
 
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
1070
 
        response = request.execute('base')
1071
 
        self.assertEquals(
1072
 
            smart_req.SuccessfulSmartServerResponse(("../foo",)),
1073
 
            response)
1074
 
 
1075
 
 
1076
 
class TestSmartServerBranchRequestSetParent(tests.TestCaseWithMemoryTransport):
1077
 
 
1078
 
    def test_set_parent_none(self):
1079
 
        branch = self.make_branch('base', format="1.9")
1080
 
        branch.lock_write()
1081
 
        branch._set_parent_location('foo')
1082
 
        branch.unlock()
1083
 
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
1084
 
            self.get_transport())
1085
 
        branch_token = branch.lock_write()
1086
 
        repo_token = branch.repository.lock_write()
1087
 
        try:
1088
 
            response = request.execute('base', branch_token, repo_token, '')
1089
 
        finally:
1090
 
            branch.repository.unlock()
1091
 
            branch.unlock()
1092
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1093
 
        self.assertEqual(None, branch.get_parent())
1094
 
 
1095
 
    def test_set_parent_something(self):
1096
 
        branch = self.make_branch('base', format="1.9")
1097
 
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
1098
 
            self.get_transport())
1099
 
        branch_token = branch.lock_write()
1100
 
        repo_token = branch.repository.lock_write()
1101
 
        try:
1102
 
            response = request.execute('base', branch_token, repo_token,
1103
 
            'http://bar/')
1104
 
        finally:
1105
 
            branch.repository.unlock()
1106
 
            branch.unlock()
1107
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1108
 
        self.assertEqual('http://bar/', branch.get_parent())
1109
 
 
1110
 
 
1111
 
class TestSmartServerBranchRequestGetTagsBytes(
1112
 
    tests.TestCaseWithMemoryTransport):
1113
 
    # Only called when the branch format and tags match [yay factory
1114
 
    # methods] so only need to test straight forward cases.
1115
 
 
1116
 
    def test_get_bytes(self):
1117
 
        base_branch = self.make_branch('base')
1118
 
        request = smart_branch.SmartServerBranchGetTagsBytes(
1119
 
            self.get_transport())
1120
 
        response = request.execute('base')
1121
 
        self.assertEquals(
1122
 
            smart_req.SuccessfulSmartServerResponse(('',)), response)
1123
 
 
1124
 
 
1125
642
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
1126
643
 
1127
644
    def test_get_stacked_on_url(self):
1129
646
        stacked_branch = self.make_branch('stacked', format='1.6')
1130
647
        # typically should be relative
1131
648
        stacked_branch.set_stacked_on_url('../base')
1132
 
        request = smart_branch.SmartServerBranchRequestGetStackedOnURL(
 
649
        request = smart.branch.SmartServerBranchRequestGetStackedOnURL(
1133
650
            self.get_transport())
1134
651
        response = request.execute('stacked')
1135
652
        self.assertEquals(
1136
 
            smart_req.SmartServerResponse(('ok', '../base')),
 
653
            SmartServerResponse(('ok', '../base')),
1137
654
            response)
1138
655
 
1139
656
 
1144
661
 
1145
662
    def test_lock_write_on_unlocked_branch(self):
1146
663
        backing = self.get_transport()
1147
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
664
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1148
665
        branch = self.make_branch('.', format='knit')
1149
666
        repository = branch.repository
1150
667
        response = request.execute('')
1151
668
        branch_nonce = branch.control_files._lock.peek().get('nonce')
1152
669
        repository_nonce = repository.control_files._lock.peek().get('nonce')
1153
 
        self.assertEqual(smart_req.SmartServerResponse(
1154
 
                ('ok', branch_nonce, repository_nonce)),
1155
 
                         response)
 
670
        self.assertEqual(
 
671
            SmartServerResponse(('ok', branch_nonce, repository_nonce)),
 
672
            response)
1156
673
        # The branch (and associated repository) is now locked.  Verify that
1157
674
        # with a new branch object.
1158
675
        new_branch = repository.bzrdir.open_branch()
1159
676
        self.assertRaises(errors.LockContention, new_branch.lock_write)
1160
 
        # Cleanup
1161
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
1162
 
        response = request.execute('', branch_nonce, repository_nonce)
1163
677
 
1164
678
    def test_lock_write_on_locked_branch(self):
1165
679
        backing = self.get_transport()
1166
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
680
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1167
681
        branch = self.make_branch('.')
1168
 
        branch_token = branch.lock_write()
 
682
        branch.lock_write()
1169
683
        branch.leave_lock_in_place()
1170
684
        branch.unlock()
1171
685
        response = request.execute('')
1172
686
        self.assertEqual(
1173
 
            smart_req.SmartServerResponse(('LockContention',)), response)
1174
 
        # Cleanup
1175
 
        branch.lock_write(branch_token)
1176
 
        branch.dont_leave_lock_in_place()
1177
 
        branch.unlock()
 
687
            SmartServerResponse(('LockContention',)), response)
1178
688
 
1179
689
    def test_lock_write_with_tokens_on_locked_branch(self):
1180
690
        backing = self.get_transport()
1181
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
691
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1182
692
        branch = self.make_branch('.', format='knit')
1183
693
        branch_token = branch.lock_write()
1184
694
        repo_token = branch.repository.lock_write()
1189
699
        response = request.execute('',
1190
700
                                   branch_token, repo_token)
1191
701
        self.assertEqual(
1192
 
            smart_req.SmartServerResponse(('ok', branch_token, repo_token)),
1193
 
            response)
1194
 
        # Cleanup
1195
 
        branch.repository.lock_write(repo_token)
1196
 
        branch.repository.dont_leave_lock_in_place()
1197
 
        branch.repository.unlock()
1198
 
        branch.lock_write(branch_token)
1199
 
        branch.dont_leave_lock_in_place()
1200
 
        branch.unlock()
 
702
            SmartServerResponse(('ok', branch_token, repo_token)), response)
1201
703
 
1202
704
    def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
1203
705
        backing = self.get_transport()
1204
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
706
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1205
707
        branch = self.make_branch('.', format='knit')
1206
708
        branch_token = branch.lock_write()
1207
709
        repo_token = branch.repository.lock_write()
1212
714
        response = request.execute('',
1213
715
                                   branch_token+'xxx', repo_token)
1214
716
        self.assertEqual(
1215
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
1216
 
        # Cleanup
1217
 
        branch.repository.lock_write(repo_token)
1218
 
        branch.repository.dont_leave_lock_in_place()
1219
 
        branch.repository.unlock()
1220
 
        branch.lock_write(branch_token)
1221
 
        branch.dont_leave_lock_in_place()
1222
 
        branch.unlock()
 
717
            SmartServerResponse(('TokenMismatch',)), response)
1223
718
 
1224
719
    def test_lock_write_on_locked_repo(self):
1225
720
        backing = self.get_transport()
1226
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
721
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1227
722
        branch = self.make_branch('.', format='knit')
1228
 
        repo = branch.repository
1229
 
        repo_token = repo.lock_write()
1230
 
        repo.leave_lock_in_place()
1231
 
        repo.unlock()
 
723
        branch.repository.lock_write()
 
724
        branch.repository.leave_lock_in_place()
 
725
        branch.repository.unlock()
1232
726
        response = request.execute('')
1233
727
        self.assertEqual(
1234
 
            smart_req.SmartServerResponse(('LockContention',)), response)
1235
 
        # Cleanup
1236
 
        repo.lock_write(repo_token)
1237
 
        repo.dont_leave_lock_in_place()
1238
 
        repo.unlock()
 
728
            SmartServerResponse(('LockContention',)), response)
1239
729
 
1240
730
    def test_lock_write_on_readonly_transport(self):
1241
731
        backing = self.get_readonly_transport()
1242
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
732
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1243
733
        branch = self.make_branch('.')
1244
734
        root = self.get_transport().clone('/')
1245
735
        path = urlutils.relative_url(root.base, self.get_transport().base)
1256
746
 
1257
747
    def test_unlock_on_locked_branch_and_repo(self):
1258
748
        backing = self.get_transport()
1259
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
749
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1260
750
        branch = self.make_branch('.', format='knit')
1261
751
        # Lock the branch
1262
752
        branch_token = branch.lock_write()
1270
760
        response = request.execute('',
1271
761
                                   branch_token, repo_token)
1272
762
        self.assertEqual(
1273
 
            smart_req.SmartServerResponse(('ok',)), response)
 
763
            SmartServerResponse(('ok',)), response)
1274
764
        # The branch is now unlocked.  Verify that with a new branch
1275
765
        # object.
1276
766
        new_branch = branch.bzrdir.open_branch()
1279
769
 
1280
770
    def test_unlock_on_unlocked_branch_unlocked_repo(self):
1281
771
        backing = self.get_transport()
1282
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
772
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1283
773
        branch = self.make_branch('.', format='knit')
1284
774
        response = request.execute(
1285
775
            '', 'branch token', 'repo token')
1286
776
        self.assertEqual(
1287
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
777
            SmartServerResponse(('TokenMismatch',)), response)
1288
778
 
1289
779
    def test_unlock_on_unlocked_branch_locked_repo(self):
1290
780
        backing = self.get_transport()
1291
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
781
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1292
782
        branch = self.make_branch('.', format='knit')
1293
783
        # Lock the repository.
1294
784
        repo_token = branch.repository.lock_write()
1299
789
        response = request.execute(
1300
790
            '', 'branch token', repo_token)
1301
791
        self.assertEqual(
1302
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
1303
 
        # Cleanup
1304
 
        branch.repository.lock_write(repo_token)
1305
 
        branch.repository.dont_leave_lock_in_place()
1306
 
        branch.repository.unlock()
 
792
            SmartServerResponse(('TokenMismatch',)), response)
1307
793
 
1308
794
 
1309
795
class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport):
1315
801
        # its the exact path being looked at and the server is not
1316
802
        # searching.
1317
803
        backing = self.get_transport()
1318
 
        request = smart_repo.SmartServerRepositoryRequest(backing)
 
804
        request = smart.repository.SmartServerRepositoryRequest(backing)
1319
805
        self.make_repository('.', shared=True)
1320
806
        self.make_bzrdir('subdir')
1321
807
        self.assertRaises(errors.NoRepositoryPresent,
1327
813
    def test_trivial_bzipped(self):
1328
814
        # This tests that the wire encoding is actually bzipped
1329
815
        backing = self.get_transport()
1330
 
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
 
816
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1331
817
        tree = self.make_branch_and_memory_tree('.')
1332
818
 
1333
819
        self.assertEqual(None,
1334
820
            request.execute('', 'missing-id'))
1335
 
        # Note that it returns a body that is bzipped.
1336
 
        self.assertEqual(
1337
 
            smart_req.SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1338
 
            request.do_body('\n\n0\n'))
1339
 
 
1340
 
    def test_trivial_include_missing(self):
1341
 
        backing = self.get_transport()
1342
 
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1343
 
        tree = self.make_branch_and_memory_tree('.')
1344
 
 
1345
 
        self.assertEqual(None,
1346
 
            request.execute('', 'missing-id', 'include-missing:'))
1347
 
        self.assertEqual(
1348
 
            smart_req.SuccessfulSmartServerResponse(('ok', ),
1349
 
                bz2.compress('missing:missing-id')),
1350
 
            request.do_body('\n\n0\n'))
1351
 
 
1352
 
 
1353
 
class TestSmartServerRepositoryGetRevisionGraph(
1354
 
    tests.TestCaseWithMemoryTransport):
 
821
        # Note that it returns a body (of '' bzipped).
 
822
        self.assertEqual(
 
823
            SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
 
824
            request.do_body('\n\n0\n'))
 
825
 
 
826
 
 
827
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
1355
828
 
1356
829
    def test_none_argument(self):
1357
830
        backing = self.get_transport()
1358
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
831
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1359
832
        tree = self.make_branch_and_memory_tree('.')
1360
833
        tree.lock_write()
1361
834
        tree.add('')
1370
843
        response.body = '\n'.join(sorted(response.body.split('\n')))
1371
844
 
1372
845
        self.assertEqual(
1373
 
            smart_req.SmartServerResponse(('ok', ), '\n'.join(lines)), response)
 
846
            SmartServerResponse(('ok', ), '\n'.join(lines)), response)
1374
847
 
1375
848
    def test_specific_revision_argument(self):
1376
849
        backing = self.get_transport()
1377
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
850
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1378
851
        tree = self.make_branch_and_memory_tree('.')
1379
852
        tree.lock_write()
1380
853
        tree.add('')
1383
856
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1384
857
        tree.unlock()
1385
858
 
1386
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), rev_id_utf8),
 
859
        self.assertEqual(SmartServerResponse(('ok', ), rev_id_utf8),
1387
860
            request.execute('', rev_id_utf8))
1388
861
 
1389
862
    def test_no_such_revision(self):
1390
863
        backing = self.get_transport()
1391
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
864
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1392
865
        tree = self.make_branch_and_memory_tree('.')
1393
866
        tree.lock_write()
1394
867
        tree.add('')
1396
869
        tree.unlock()
1397
870
 
1398
871
        # Note that it still returns body (of zero bytes).
1399
 
        self.assertEqual(smart_req.SmartServerResponse(
1400
 
                ('nosuchrevision', 'missingrevision', ), ''),
1401
 
                         request.execute('', 'missingrevision'))
1402
 
 
1403
 
 
1404
 
class TestSmartServerRepositoryGetRevIdForRevno(
1405
 
    tests.TestCaseWithMemoryTransport):
1406
 
 
1407
 
    def test_revno_found(self):
1408
 
        backing = self.get_transport()
1409
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1410
 
        tree = self.make_branch_and_memory_tree('.')
1411
 
        tree.lock_write()
1412
 
        tree.add('')
1413
 
        rev1_id_utf8 = u'\xc8'.encode('utf-8')
1414
 
        rev2_id_utf8 = u'\xc9'.encode('utf-8')
1415
 
        tree.commit('1st commit', rev_id=rev1_id_utf8)
1416
 
        tree.commit('2nd commit', rev_id=rev2_id_utf8)
1417
 
        tree.unlock()
1418
 
 
1419
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', rev1_id_utf8)),
1420
 
            request.execute('', 1, (2, rev2_id_utf8)))
1421
 
 
1422
 
    def test_known_revid_missing(self):
1423
 
        backing = self.get_transport()
1424
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1425
 
        repo = self.make_repository('.')
1426
 
        self.assertEqual(
1427
 
            smart_req.FailedSmartServerResponse(('nosuchrevision', 'ghost')),
1428
 
            request.execute('', 1, (2, 'ghost')))
1429
 
 
1430
 
    def test_history_incomplete(self):
1431
 
        backing = self.get_transport()
1432
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1433
 
        parent = self.make_branch_and_memory_tree('parent', format='1.9')
1434
 
        parent.lock_write()
1435
 
        parent.add([''], ['TREE_ROOT'])
1436
 
        r1 = parent.commit(message='first commit')
1437
 
        r2 = parent.commit(message='second commit')
1438
 
        parent.unlock()
1439
 
        local = self.make_branch_and_memory_tree('local', format='1.9')
1440
 
        local.branch.pull(parent.branch)
1441
 
        local.set_parent_ids([r2])
1442
 
        r3 = local.commit(message='local commit')
1443
 
        local.branch.create_clone_on_transport(
1444
 
            self.get_transport('stacked'), stacked_on=self.get_url('parent'))
1445
 
        self.assertEqual(
1446
 
            smart_req.SmartServerResponse(('history-incomplete', 2, r2)),
1447
 
            request.execute('stacked', 1, (3, r3)))
1448
 
 
1449
 
 
1450
 
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1451
 
 
1452
 
    def make_two_commit_repo(self):
1453
 
        tree = self.make_branch_and_memory_tree('.')
1454
 
        tree.lock_write()
1455
 
        tree.add('')
1456
 
        r1 = tree.commit('1st commit')
1457
 
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1458
 
        tree.unlock()
1459
 
        repo = tree.branch.repository
1460
 
        return repo, r1, r2
1461
 
 
1462
 
    def test_ancestry_of(self):
1463
 
        """The search argument may be a 'ancestry-of' some heads'."""
1464
 
        backing = self.get_transport()
1465
 
        request = smart_repo.SmartServerRepositoryGetStream(backing)
1466
 
        repo, r1, r2 = self.make_two_commit_repo()
1467
 
        fetch_spec = ['ancestry-of', r2]
1468
 
        lines = '\n'.join(fetch_spec)
1469
 
        request.execute('', repo._format.network_name())
1470
 
        response = request.do_body(lines)
1471
 
        self.assertEqual(('ok',), response.args)
1472
 
        stream_bytes = ''.join(response.body_stream)
1473
 
        self.assertStartsWith(stream_bytes, 'Bazaar pack format 1')
1474
 
 
1475
 
    def test_search(self):
1476
 
        """The search argument may be a 'search' of some explicit keys."""
1477
 
        backing = self.get_transport()
1478
 
        request = smart_repo.SmartServerRepositoryGetStream(backing)
1479
 
        repo, r1, r2 = self.make_two_commit_repo()
1480
 
        fetch_spec = ['search', '%s %s' % (r1, r2), 'null:', '2']
1481
 
        lines = '\n'.join(fetch_spec)
1482
 
        request.execute('', repo._format.network_name())
1483
 
        response = request.do_body(lines)
1484
 
        self.assertEqual(('ok',), response.args)
1485
 
        stream_bytes = ''.join(response.body_stream)
1486
 
        self.assertStartsWith(stream_bytes, 'Bazaar pack format 1')
 
872
        self.assertEqual(
 
873
            SmartServerResponse(('nosuchrevision', 'missingrevision', ), ''),
 
874
            request.execute('', 'missingrevision'))
1487
875
 
1488
876
 
1489
877
class TestSmartServerRequestHasRevision(tests.TestCaseWithMemoryTransport):
1491
879
    def test_missing_revision(self):
1492
880
        """For a missing revision, ('no', ) is returned."""
1493
881
        backing = self.get_transport()
1494
 
        request = smart_repo.SmartServerRequestHasRevision(backing)
 
882
        request = smart.repository.SmartServerRequestHasRevision(backing)
1495
883
        self.make_repository('.')
1496
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
884
        self.assertEqual(SmartServerResponse(('no', )),
1497
885
            request.execute('', 'revid'))
1498
886
 
1499
887
    def test_present_revision(self):
1500
888
        """For a present revision, ('yes', ) is returned."""
1501
889
        backing = self.get_transport()
1502
 
        request = smart_repo.SmartServerRequestHasRevision(backing)
 
890
        request = smart.repository.SmartServerRequestHasRevision(backing)
1503
891
        tree = self.make_branch_and_memory_tree('.')
1504
892
        tree.lock_write()
1505
893
        tree.add('')
1507
895
        r1 = tree.commit('a commit', rev_id=rev_id_utf8)
1508
896
        tree.unlock()
1509
897
        self.assertTrue(tree.branch.repository.has_revision(rev_id_utf8))
1510
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
898
        self.assertEqual(SmartServerResponse(('yes', )),
1511
899
            request.execute('', rev_id_utf8))
1512
900
 
1513
901
 
1516
904
    def test_empty_revid(self):
1517
905
        """With an empty revid, we get only size an number and revisions"""
1518
906
        backing = self.get_transport()
1519
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
907
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1520
908
        repository = self.make_repository('.')
1521
909
        stats = repository.gather_stats()
1522
910
        expected_body = 'revisions: 0\n'
1523
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
911
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1524
912
                         request.execute('', '', 'no'))
1525
913
 
1526
914
    def test_revid_with_committers(self):
1527
915
        """For a revid we get more infos."""
1528
916
        backing = self.get_transport()
1529
917
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1530
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
918
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1531
919
        tree = self.make_branch_and_memory_tree('.')
1532
920
        tree.lock_write()
1533
921
        tree.add('')
1541
929
        expected_body = ('firstrev: 123456.200 3600\n'
1542
930
                         'latestrev: 654321.400 0\n'
1543
931
                         'revisions: 2\n')
1544
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
932
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1545
933
                         request.execute('',
1546
934
                                         rev_id_utf8, 'no'))
1547
935
 
1549
937
        """For a revid and requesting committers we get the whole thing."""
1550
938
        backing = self.get_transport()
1551
939
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1552
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
940
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1553
941
        tree = self.make_branch_and_memory_tree('.')
1554
942
        tree.lock_write()
1555
943
        tree.add('')
1565
953
                         'firstrev: 123456.200 3600\n'
1566
954
                         'latestrev: 654321.400 0\n'
1567
955
                         'revisions: 2\n')
1568
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
956
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1569
957
                         request.execute('',
1570
958
                                         rev_id_utf8, 'yes'))
1571
959
 
1575
963
    def test_is_shared(self):
1576
964
        """For a shared repository, ('yes', ) is returned."""
1577
965
        backing = self.get_transport()
1578
 
        request = smart_repo.SmartServerRepositoryIsShared(backing)
 
966
        request = smart.repository.SmartServerRepositoryIsShared(backing)
1579
967
        self.make_repository('.', shared=True)
1580
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
968
        self.assertEqual(SmartServerResponse(('yes', )),
1581
969
            request.execute('', ))
1582
970
 
1583
971
    def test_is_not_shared(self):
1584
972
        """For a shared repository, ('no', ) is returned."""
1585
973
        backing = self.get_transport()
1586
 
        request = smart_repo.SmartServerRepositoryIsShared(backing)
 
974
        request = smart.repository.SmartServerRepositoryIsShared(backing)
1587
975
        self.make_repository('.', shared=False)
1588
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
976
        self.assertEqual(SmartServerResponse(('no', )),
1589
977
            request.execute('', ))
1590
978
 
1591
979
 
1592
980
class TestSmartServerRepositoryLockWrite(tests.TestCaseWithMemoryTransport):
1593
981
 
 
982
    def setUp(self):
 
983
        tests.TestCaseWithMemoryTransport.setUp(self)
 
984
 
1594
985
    def test_lock_write_on_unlocked_repo(self):
1595
986
        backing = self.get_transport()
1596
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
987
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1597
988
        repository = self.make_repository('.', format='knit')
1598
989
        response = request.execute('')
1599
990
        nonce = repository.control_files._lock.peek().get('nonce')
1600
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
 
991
        self.assertEqual(SmartServerResponse(('ok', nonce)), response)
1601
992
        # The repository is now locked.  Verify that with a new repository
1602
993
        # object.
1603
994
        new_repo = repository.bzrdir.open_repository()
1604
995
        self.assertRaises(errors.LockContention, new_repo.lock_write)
1605
 
        # Cleanup
1606
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
1607
 
        response = request.execute('', nonce)
1608
996
 
1609
997
    def test_lock_write_on_locked_repo(self):
1610
998
        backing = self.get_transport()
1611
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
999
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1612
1000
        repository = self.make_repository('.', format='knit')
1613
 
        repo_token = repository.lock_write()
 
1001
        repository.lock_write()
1614
1002
        repository.leave_lock_in_place()
1615
1003
        repository.unlock()
1616
1004
        response = request.execute('')
1617
1005
        self.assertEqual(
1618
 
            smart_req.SmartServerResponse(('LockContention',)), response)
1619
 
        # Cleanup
1620
 
        repository.lock_write(repo_token)
1621
 
        repository.dont_leave_lock_in_place()
1622
 
        repository.unlock()
 
1006
            SmartServerResponse(('LockContention',)), response)
1623
1007
 
1624
1008
    def test_lock_write_on_readonly_transport(self):
1625
1009
        backing = self.get_readonly_transport()
1626
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1010
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1627
1011
        repository = self.make_repository('.', format='knit')
1628
1012
        response = request.execute('')
1629
1013
        self.assertFalse(response.is_successful())
1630
1014
        self.assertEqual('LockFailed', response.args[0])
1631
1015
 
1632
1016
 
1633
 
class TestInsertStreamBase(tests.TestCaseWithMemoryTransport):
1634
 
 
1635
 
    def make_empty_byte_stream(self, repo):
1636
 
        byte_stream = smart_repo._stream_to_byte_stream([], repo._format)
1637
 
        return ''.join(byte_stream)
1638
 
 
1639
 
 
1640
 
class TestSmartServerRepositoryInsertStream(TestInsertStreamBase):
1641
 
 
1642
 
    def test_insert_stream_empty(self):
1643
 
        backing = self.get_transport()
1644
 
        request = smart_repo.SmartServerRepositoryInsertStream(backing)
1645
 
        repository = self.make_repository('.')
1646
 
        response = request.execute('', '')
1647
 
        self.assertEqual(None, response)
1648
 
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1649
 
        self.assertEqual(None, response)
1650
 
        response = request.do_end()
1651
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1652
 
 
1653
 
 
1654
 
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
1655
 
 
1656
 
    def test_insert_stream_empty(self):
1657
 
        backing = self.get_transport()
1658
 
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1659
 
            backing)
1660
 
        repository = self.make_repository('.', format='knit')
1661
 
        lock_token = repository.lock_write()
1662
 
        response = request.execute('', '', lock_token)
1663
 
        self.assertEqual(None, response)
1664
 
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1665
 
        self.assertEqual(None, response)
1666
 
        response = request.do_end()
1667
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1668
 
        repository.unlock()
1669
 
 
1670
 
    def test_insert_stream_with_wrong_lock_token(self):
1671
 
        backing = self.get_transport()
1672
 
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1673
 
            backing)
1674
 
        repository = self.make_repository('.', format='knit')
1675
 
        lock_token = repository.lock_write()
1676
 
        self.assertRaises(
1677
 
            errors.TokenMismatch, request.execute, '', '', 'wrong-token')
1678
 
        repository.unlock()
1679
 
 
1680
 
 
1681
1017
class TestSmartServerRepositoryUnlock(tests.TestCaseWithMemoryTransport):
1682
1018
 
1683
1019
    def setUp(self):
1685
1021
 
1686
1022
    def test_unlock_on_locked_repo(self):
1687
1023
        backing = self.get_transport()
1688
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1024
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1689
1025
        repository = self.make_repository('.', format='knit')
1690
1026
        token = repository.lock_write()
1691
1027
        repository.leave_lock_in_place()
1692
1028
        repository.unlock()
1693
1029
        response = request.execute('', token)
1694
1030
        self.assertEqual(
1695
 
            smart_req.SmartServerResponse(('ok',)), response)
 
1031
            SmartServerResponse(('ok',)), response)
1696
1032
        # The repository is now unlocked.  Verify that with a new repository
1697
1033
        # object.
1698
1034
        new_repo = repository.bzrdir.open_repository()
1701
1037
 
1702
1038
    def test_unlock_on_unlocked_repo(self):
1703
1039
        backing = self.get_transport()
1704
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1040
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1705
1041
        repository = self.make_repository('.', format='knit')
1706
1042
        response = request.execute('', 'some token')
1707
1043
        self.assertEqual(
1708
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1044
            SmartServerResponse(('TokenMismatch',)), response)
1709
1045
 
1710
1046
 
1711
1047
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1712
1048
 
1713
1049
    def test_is_readonly_no(self):
1714
1050
        backing = self.get_transport()
1715
 
        request = smart_req.SmartServerIsReadonly(backing)
 
1051
        request = smart.request.SmartServerIsReadonly(backing)
1716
1052
        response = request.execute()
1717
1053
        self.assertEqual(
1718
 
            smart_req.SmartServerResponse(('no',)), response)
 
1054
            SmartServerResponse(('no',)), response)
1719
1055
 
1720
1056
    def test_is_readonly_yes(self):
1721
1057
        backing = self.get_readonly_transport()
1722
 
        request = smart_req.SmartServerIsReadonly(backing)
 
1058
        request = smart.request.SmartServerIsReadonly(backing)
1723
1059
        response = request.execute()
1724
1060
        self.assertEqual(
1725
 
            smart_req.SmartServerResponse(('yes',)), response)
1726
 
 
1727
 
 
1728
 
class TestSmartServerRepositorySetMakeWorkingTrees(
1729
 
    tests.TestCaseWithMemoryTransport):
 
1061
            SmartServerResponse(('yes',)), response)
 
1062
 
 
1063
 
 
1064
class TestSmartServerRepositorySetMakeWorkingTrees(tests.TestCaseWithMemoryTransport):
1730
1065
 
1731
1066
    def test_set_false(self):
1732
1067
        backing = self.get_transport()
1733
1068
        repo = self.make_repository('.', shared=True)
1734
1069
        repo.set_make_working_trees(True)
1735
 
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
 
1070
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1736
1071
        request = request_class(backing)
1737
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1072
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1738
1073
            request.execute('', 'False'))
1739
1074
        repo = repo.bzrdir.open_repository()
1740
1075
        self.assertFalse(repo.make_working_trees())
1743
1078
        backing = self.get_transport()
1744
1079
        repo = self.make_repository('.', shared=True)
1745
1080
        repo.set_make_working_trees(False)
1746
 
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
 
1081
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1747
1082
        request = request_class(backing)
1748
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1083
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1749
1084
            request.execute('', 'True'))
1750
1085
        repo = repo.bzrdir.open_repository()
1751
1086
        self.assertTrue(repo.make_working_trees())
1767
1102
 
1768
1103
    def test_autopack_needed(self):
1769
1104
        repo = self.make_repo_needing_autopacking()
1770
 
        repo.lock_write()
1771
 
        self.addCleanup(repo.unlock)
1772
1105
        backing = self.get_transport()
1773
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1106
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1774
1107
            backing)
1775
1108
        response = request.execute('')
1776
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1109
        self.assertEqual(SmartServerResponse(('ok',)), response)
1777
1110
        repo._pack_collection.reload_pack_names()
1778
1111
        self.assertEqual(1, len(repo._pack_collection.names()))
1779
1112
 
1780
1113
    def test_autopack_not_needed(self):
1781
1114
        tree = self.make_branch_and_tree('.', format='pack-0.92')
1782
1115
        repo = tree.branch.repository
1783
 
        repo.lock_write()
1784
 
        self.addCleanup(repo.unlock)
1785
1116
        for x in range(9):
1786
1117
            tree.commit('commit %s' % x)
1787
1118
        backing = self.get_transport()
1788
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1119
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1789
1120
            backing)
1790
1121
        response = request.execute('')
1791
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1122
        self.assertEqual(SmartServerResponse(('ok',)), response)
1792
1123
        repo._pack_collection.reload_pack_names()
1793
1124
        self.assertEqual(9, len(repo._pack_collection.names()))
1794
1125
 
1796
1127
        """A request to autopack a non-pack repo is a no-op."""
1797
1128
        repo = self.make_repository('.', format='knit')
1798
1129
        backing = self.get_transport()
1799
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1130
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1800
1131
            backing)
1801
1132
        response = request.execute('')
1802
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
1803
 
 
1804
 
 
1805
 
class TestSmartServerVfsGet(tests.TestCaseWithMemoryTransport):
1806
 
 
1807
 
    def test_unicode_path(self):
1808
 
        """VFS requests expect unicode paths to be escaped."""
1809
 
        filename = u'foo\N{INTERROBANG}'
1810
 
        filename_escaped = urlutils.escape(filename)
1811
 
        backing = self.get_transport()
1812
 
        request = vfs.GetRequest(backing)
1813
 
        backing.put_bytes_non_atomic(filename_escaped, 'contents')
1814
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'contents'),
1815
 
            request.execute(filename_escaped))
 
1133
        self.assertEqual(SmartServerResponse(('ok',)), response)
1816
1134
 
1817
1135
 
1818
1136
class TestHandlers(tests.TestCase):
1822
1140
        """All registered request_handlers can be found."""
1823
1141
        # If there's a typo in a register_lazy call, this loop will fail with
1824
1142
        # an AttributeError.
1825
 
        for key, item in smart_req.request_handlers.iteritems():
 
1143
        for key, item in smart.request.request_handlers.iteritems():
1826
1144
            pass
1827
1145
 
1828
 
    def assertHandlerEqual(self, verb, handler):
1829
 
        self.assertEqual(smart_req.request_handlers.get(verb), handler)
1830
 
 
1831
1146
    def test_registered_methods(self):
1832
1147
        """Test that known methods are registered to the correct object."""
1833
 
        self.assertHandlerEqual('Branch.get_config_file',
1834
 
            smart_branch.SmartServerBranchGetConfigFile)
1835
 
        self.assertHandlerEqual('Branch.get_parent',
1836
 
            smart_branch.SmartServerBranchGetParent)
1837
 
        self.assertHandlerEqual('Branch.get_tags_bytes',
1838
 
            smart_branch.SmartServerBranchGetTagsBytes)
1839
 
        self.assertHandlerEqual('Branch.lock_write',
1840
 
            smart_branch.SmartServerBranchRequestLockWrite)
1841
 
        self.assertHandlerEqual('Branch.last_revision_info',
1842
 
            smart_branch.SmartServerBranchRequestLastRevisionInfo)
1843
 
        self.assertHandlerEqual('Branch.revision_history',
1844
 
            smart_branch.SmartServerRequestRevisionHistory)
1845
 
        self.assertHandlerEqual('Branch.set_config_option',
1846
 
            smart_branch.SmartServerBranchRequestSetConfigOption)
1847
 
        self.assertHandlerEqual('Branch.set_last_revision',
1848
 
            smart_branch.SmartServerBranchRequestSetLastRevision)
1849
 
        self.assertHandlerEqual('Branch.set_last_revision_info',
1850
 
            smart_branch.SmartServerBranchRequestSetLastRevisionInfo)
1851
 
        self.assertHandlerEqual('Branch.set_last_revision_ex',
1852
 
            smart_branch.SmartServerBranchRequestSetLastRevisionEx)
1853
 
        self.assertHandlerEqual('Branch.set_parent_location',
1854
 
            smart_branch.SmartServerBranchRequestSetParentLocation)
1855
 
        self.assertHandlerEqual('Branch.unlock',
1856
 
            smart_branch.SmartServerBranchRequestUnlock)
1857
 
        self.assertHandlerEqual('BzrDir.find_repository',
1858
 
            smart_dir.SmartServerRequestFindRepositoryV1)
1859
 
        self.assertHandlerEqual('BzrDir.find_repositoryV2',
1860
 
            smart_dir.SmartServerRequestFindRepositoryV2)
1861
 
        self.assertHandlerEqual('BzrDirFormat.initialize',
1862
 
            smart_dir.SmartServerRequestInitializeBzrDir)
1863
 
        self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
1864
 
            smart_dir.SmartServerRequestBzrDirInitializeEx)
1865
 
        self.assertHandlerEqual('BzrDir.cloning_metadir',
1866
 
            smart_dir.SmartServerBzrDirRequestCloningMetaDir)
1867
 
        self.assertHandlerEqual('BzrDir.get_config_file',
1868
 
            smart_dir.SmartServerBzrDirRequestConfigFile)
1869
 
        self.assertHandlerEqual('BzrDir.open_branch',
1870
 
            smart_dir.SmartServerRequestOpenBranch)
1871
 
        self.assertHandlerEqual('BzrDir.open_branchV2',
1872
 
            smart_dir.SmartServerRequestOpenBranchV2)
1873
 
        self.assertHandlerEqual('BzrDir.open_branchV3',
1874
 
            smart_dir.SmartServerRequestOpenBranchV3)
1875
 
        self.assertHandlerEqual('PackRepository.autopack',
1876
 
            smart_packrepo.SmartServerPackRepositoryAutopack)
1877
 
        self.assertHandlerEqual('Repository.gather_stats',
1878
 
            smart_repo.SmartServerRepositoryGatherStats)
1879
 
        self.assertHandlerEqual('Repository.get_parent_map',
1880
 
            smart_repo.SmartServerRepositoryGetParentMap)
1881
 
        self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1882
 
            smart_repo.SmartServerRepositoryGetRevIdForRevno)
1883
 
        self.assertHandlerEqual('Repository.get_revision_graph',
1884
 
            smart_repo.SmartServerRepositoryGetRevisionGraph)
1885
 
        self.assertHandlerEqual('Repository.get_stream',
1886
 
            smart_repo.SmartServerRepositoryGetStream)
1887
 
        self.assertHandlerEqual('Repository.has_revision',
1888
 
            smart_repo.SmartServerRequestHasRevision)
1889
 
        self.assertHandlerEqual('Repository.insert_stream',
1890
 
            smart_repo.SmartServerRepositoryInsertStream)
1891
 
        self.assertHandlerEqual('Repository.insert_stream_locked',
1892
 
            smart_repo.SmartServerRepositoryInsertStreamLocked)
1893
 
        self.assertHandlerEqual('Repository.is_shared',
1894
 
            smart_repo.SmartServerRepositoryIsShared)
1895
 
        self.assertHandlerEqual('Repository.lock_write',
1896
 
            smart_repo.SmartServerRepositoryLockWrite)
1897
 
        self.assertHandlerEqual('Repository.tarball',
1898
 
            smart_repo.SmartServerRepositoryTarball)
1899
 
        self.assertHandlerEqual('Repository.unlock',
1900
 
            smart_repo.SmartServerRepositoryUnlock)
1901
 
        self.assertHandlerEqual('Transport.is_readonly',
1902
 
            smart_req.SmartServerIsReadonly)
 
1148
        self.assertEqual(
 
1149
            smart.request.request_handlers.get('Branch.get_config_file'),
 
1150
            smart.branch.SmartServerBranchGetConfigFile)
 
1151
        self.assertEqual(
 
1152
            smart.request.request_handlers.get('Branch.lock_write'),
 
1153
            smart.branch.SmartServerBranchRequestLockWrite)
 
1154
        self.assertEqual(
 
1155
            smart.request.request_handlers.get('Branch.last_revision_info'),
 
1156
            smart.branch.SmartServerBranchRequestLastRevisionInfo)
 
1157
        self.assertEqual(
 
1158
            smart.request.request_handlers.get('Branch.revision_history'),
 
1159
            smart.branch.SmartServerRequestRevisionHistory)
 
1160
        self.assertEqual(
 
1161
            smart.request.request_handlers.get('Branch.set_last_revision'),
 
1162
            smart.branch.SmartServerBranchRequestSetLastRevision)
 
1163
        self.assertEqual(
 
1164
            smart.request.request_handlers.get('Branch.set_last_revision_info'),
 
1165
            smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
 
1166
        self.assertEqual(
 
1167
            smart.request.request_handlers.get('Branch.unlock'),
 
1168
            smart.branch.SmartServerBranchRequestUnlock)
 
1169
        self.assertEqual(
 
1170
            smart.request.request_handlers.get('BzrDir.find_repository'),
 
1171
            smart.bzrdir.SmartServerRequestFindRepositoryV1)
 
1172
        self.assertEqual(
 
1173
            smart.request.request_handlers.get('BzrDir.find_repositoryV2'),
 
1174
            smart.bzrdir.SmartServerRequestFindRepositoryV2)
 
1175
        self.assertEqual(
 
1176
            smart.request.request_handlers.get('BzrDirFormat.initialize'),
 
1177
            smart.bzrdir.SmartServerRequestInitializeBzrDir)
 
1178
        self.assertEqual(
 
1179
            smart.request.request_handlers.get('BzrDir.open_branch'),
 
1180
            smart.bzrdir.SmartServerRequestOpenBranch)
 
1181
        self.assertEqual(
 
1182
            smart.request.request_handlers.get('PackRepository.autopack'),
 
1183
            smart.packrepository.SmartServerPackRepositoryAutopack)
 
1184
        self.assertEqual(
 
1185
            smart.request.request_handlers.get('Repository.gather_stats'),
 
1186
            smart.repository.SmartServerRepositoryGatherStats)
 
1187
        self.assertEqual(
 
1188
            smart.request.request_handlers.get('Repository.get_parent_map'),
 
1189
            smart.repository.SmartServerRepositoryGetParentMap)
 
1190
        self.assertEqual(
 
1191
            smart.request.request_handlers.get(
 
1192
                'Repository.get_revision_graph'),
 
1193
            smart.repository.SmartServerRepositoryGetRevisionGraph)
 
1194
        self.assertEqual(
 
1195
            smart.request.request_handlers.get('Repository.has_revision'),
 
1196
            smart.repository.SmartServerRequestHasRevision)
 
1197
        self.assertEqual(
 
1198
            smart.request.request_handlers.get('Repository.is_shared'),
 
1199
            smart.repository.SmartServerRepositoryIsShared)
 
1200
        self.assertEqual(
 
1201
            smart.request.request_handlers.get('Repository.lock_write'),
 
1202
            smart.repository.SmartServerRepositoryLockWrite)
 
1203
        self.assertEqual(
 
1204
            smart.request.request_handlers.get('Repository.StreamSource.get_stream'),
 
1205
            smart.repository.SmartServerRepositoryStreamSourceGetStream)
 
1206
        self.assertEqual(
 
1207
            smart.request.request_handlers.get('Repository.tarball'),
 
1208
            smart.repository.SmartServerRepositoryTarball)
 
1209
        self.assertEqual(
 
1210
            smart.request.request_handlers.get('Repository.unlock'),
 
1211
            smart.repository.SmartServerRepositoryUnlock)
 
1212
        self.assertEqual(
 
1213
            smart.request.request_handlers.get('Transport.is_readonly'),
 
1214
            smart.request.SmartServerIsReadonly)