← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-04-09 20:23:07 UTC
  • mfrom: (4265.1.4 bbc-merge)
  • Revision ID: pqm@pqm.ubuntu.com-20090409202307-n0depb16qepoe21o
(jam) Change _fetch_uses_deltas = False for CHK repos until we can
        write a better fix.

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
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, bzrlib.smart.bzrdir as smart_dir
 
42
import bzrlib.smart.packrepository
 
43
import bzrlib.smart.repository
 
44
from bzrlib.smart.request import (
 
45
    FailedSmartServerResponse,
 
46
    SmartServerRequest,
 
47
    SmartServerResponse,
 
48
    SuccessfulSmartServerResponse,
 
49
    )
 
50
from bzrlib.tests import (
 
51
    split_suite_by_re,
 
52
    )
 
53
from bzrlib.transport import chroot, get_transport
 
54
from bzrlib.util import bencode
56
55
 
57
56
 
58
57
def load_tests(standard_tests, module, loader):
59
58
    """Multiply tests version and protocol consistency."""
60
59
    # FindRepository tests.
 
60
    bzrdir_mod = bzrlib.smart.bzrdir
61
61
    scenarios = [
62
62
        ("find_repository", {
63
 
            "_request_class": smart_dir.SmartServerRequestFindRepositoryV1}),
 
63
            "_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV1}),
64
64
        ("find_repositoryV2", {
65
 
            "_request_class": smart_dir.SmartServerRequestFindRepositoryV2}),
 
65
            "_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV2}),
66
66
        ("find_repositoryV3", {
67
 
            "_request_class": smart_dir.SmartServerRequestFindRepositoryV3}),
 
67
            "_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV3}),
68
68
        ]
69
 
    to_adapt, result = tests.split_suite_by_re(standard_tests,
 
69
    to_adapt, result = split_suite_by_re(standard_tests,
70
70
        "TestSmartServerRequestFindRepository")
71
 
    v2_only, v1_and_2 = tests.split_suite_by_re(to_adapt,
 
71
    v2_only, v1_and_2 = split_suite_by_re(to_adapt,
72
72
        "_v2")
73
73
    tests.multiply_tests(v1_and_2, scenarios, result)
74
74
    # The first scenario is only applicable to v1 protocols, it is deleted
80
80
class TestCaseWithChrootedTransport(tests.TestCaseWithTransport):
81
81
 
82
82
    def setUp(self):
83
 
        self.vfs_transport_factory = memory.MemoryServer
84
83
        tests.TestCaseWithTransport.setUp(self)
85
84
        self._chroot_server = None
86
85
 
88
87
        if self._chroot_server is None:
89
88
            backing_transport = tests.TestCaseWithTransport.get_transport(self)
90
89
            self._chroot_server = chroot.ChrootServer(backing_transport)
91
 
            self.start_server(self._chroot_server)
92
 
        t = transport.get_transport(self._chroot_server.get_url())
 
90
            self._chroot_server.setUp()
 
91
            self.addCleanup(self._chroot_server.tearDown)
 
92
        t = get_transport(self._chroot_server.get_url())
93
93
        if relpath is not None:
94
94
            t = t.clone(relpath)
95
95
        return t
96
96
 
97
97
 
98
 
class TestCaseWithSmartMedium(tests.TestCaseWithMemoryTransport):
 
98
class TestCaseWithSmartMedium(tests.TestCaseWithTransport):
99
99
 
100
100
    def setUp(self):
101
101
        super(TestCaseWithSmartMedium, self).setUp()
106
106
        self.transport_server = self.make_transport_server
107
107
 
108
108
    def make_transport_server(self):
109
 
        return test_server.SmartTCPServer_for_testing('-' + self.id())
 
109
        return smart.server.SmartTCPServer_for_testing('-' + self.id())
110
110
 
111
111
    def get_smart_medium(self):
112
112
        """Get a smart medium to use in tests."""
113
113
        return self.get_transport().get_smart_medium()
114
114
 
115
115
 
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
116
class TestSmartServerResponse(tests.TestCase):
136
117
 
137
118
    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', )))
 
119
        self.assertEqual(SmartServerResponse(('ok', )),
 
120
            SmartServerResponse(('ok', )))
 
121
        self.assertEqual(SmartServerResponse(('ok', ), 'body'),
 
122
            SmartServerResponse(('ok', ), 'body'))
 
123
        self.assertNotEqual(SmartServerResponse(('ok', )),
 
124
            SmartServerResponse(('notok', )))
 
125
        self.assertNotEqual(SmartServerResponse(('ok', ), 'body'),
 
126
            SmartServerResponse(('ok', )))
146
127
        self.assertNotEqual(None,
147
 
            smart_req.SmartServerResponse(('ok', )))
 
128
            SmartServerResponse(('ok', )))
148
129
 
149
130
    def test__str__(self):
150
131
        """SmartServerResponses can be stringified."""
151
132
        self.assertEqual(
152
133
            "<SuccessfulSmartServerResponse args=('args',) body='body'>",
153
 
            str(smart_req.SuccessfulSmartServerResponse(('args',), 'body')))
 
134
            str(SuccessfulSmartServerResponse(('args',), 'body')))
154
135
        self.assertEqual(
155
136
            "<FailedSmartServerResponse args=('args',) body='body'>",
156
 
            str(smart_req.FailedSmartServerResponse(('args',), 'body')))
 
137
            str(FailedSmartServerResponse(('args',), 'body')))
157
138
 
158
139
 
159
140
class TestSmartServerRequest(tests.TestCaseWithMemoryTransport):
160
141
 
161
142
    def test_translate_client_path(self):
162
143
        transport = self.get_transport()
163
 
        request = smart_req.SmartServerRequest(transport, 'foo/')
 
144
        request = SmartServerRequest(transport, 'foo/')
164
145
        self.assertEqual('./', request.translate_client_path('foo/'))
165
146
        self.assertRaises(
166
147
            errors.InvalidURLJoin, request.translate_client_path, 'foo/..')
169
150
        self.assertRaises(
170
151
            errors.PathNotChild, request.translate_client_path, 'bar/')
171
152
        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
153
 
185
154
    def test_transport_from_client_path(self):
186
155
        transport = self.get_transport()
187
 
        request = smart_req.SmartServerRequest(transport, 'foo/')
 
156
        request = SmartServerRequest(transport, 'foo/')
188
157
        self.assertEqual(
189
158
            transport.base,
190
159
            request.transport_from_client_path('foo/').base)
201
170
        local_result = dir.cloning_metadir()
202
171
        request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
203
172
        request = request_class(backing)
204
 
        expected = smart_req.SuccessfulSmartServerResponse(
 
173
        expected = SuccessfulSmartServerResponse(
205
174
            (local_result.network_name(),
206
175
            local_result.repository_format.network_name(),
207
176
            ('branch', local_result.get_branch_format().network_name())))
213
182
        referenced_branch = self.make_branch('referenced')
214
183
        dir = self.make_bzrdir('.')
215
184
        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)
 
185
        reference = BranchReferenceFormat().initialize(dir, referenced_branch)
 
186
        reference_url = BranchReferenceFormat().get_reference(dir)
219
187
        # The server shouldn't try to follow the branch reference, so it's fine
220
188
        # if the referenced branch isn't reachable.
221
189
        backing.rename('referenced', 'moved')
222
190
        request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
223
191
        request = request_class(backing)
224
 
        expected = smart_req.FailedSmartServerResponse(('BranchReference',))
 
192
        expected = FailedSmartServerResponse(('BranchReference',))
225
193
        self.assertEqual(expected, request.execute('', 'False'))
226
194
 
227
195
 
232
200
        """When there is a bzrdir present, the call succeeds."""
233
201
        backing = self.get_transport()
234
202
        self.make_bzrdir('.')
235
 
        request_class = smart_dir.SmartServerRequestCreateRepository
 
203
        request_class = bzrlib.smart.bzrdir.SmartServerRequestCreateRepository
236
204
        request = request_class(backing)
237
 
        reference_bzrdir_format = bzrdir.format_registry.get('pack-0.92')()
 
205
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
238
206
        reference_format = reference_bzrdir_format.repository_format
239
207
        network_name = reference_format.network_name()
240
 
        expected = smart_req.SuccessfulSmartServerResponse(
 
208
        expected = SuccessfulSmartServerResponse(
241
209
            ('ok', 'no', 'no', 'no', network_name))
242
210
        self.assertEqual(expected, request.execute('', network_name, 'True'))
243
211
 
250
218
        backing = self.get_transport()
251
219
        request = self._request_class(backing)
252
220
        self.make_bzrdir('.')
253
 
        self.assertEqual(smart_req.SmartServerResponse(('norepository', )),
 
221
        self.assertEqual(SmartServerResponse(('norepository', )),
254
222
            request.execute(''))
255
223
 
256
224
    def test_nonshared_repository(self):
262
230
        result = self._make_repository_and_result()
263
231
        self.assertEqual(result, request.execute(''))
264
232
        self.make_bzrdir('subdir')
265
 
        self.assertEqual(smart_req.SmartServerResponse(('norepository', )),
 
233
        self.assertEqual(SmartServerResponse(('norepository', )),
266
234
            request.execute('subdir'))
267
235
 
268
236
    def _make_repository_and_result(self, shared=False, format=None):
279
247
            subtrees = 'yes'
280
248
        else:
281
249
            subtrees = 'no'
282
 
        if repo._format.supports_external_lookups:
283
 
            external = 'yes'
284
 
        else:
285
 
            external = 'no'
286
 
        if (smart_dir.SmartServerRequestFindRepositoryV3 ==
 
250
        if (smart.bzrdir.SmartServerRequestFindRepositoryV3 ==
287
251
            self._request_class):
288
 
            return smart_req.SuccessfulSmartServerResponse(
289
 
                ('ok', '', rich_root, subtrees, external,
 
252
            return SuccessfulSmartServerResponse(
 
253
                ('ok', '', rich_root, subtrees, 'no',
290
254
                 repo._format.network_name()))
291
 
        elif (smart_dir.SmartServerRequestFindRepositoryV2 ==
 
255
        elif (smart.bzrdir.SmartServerRequestFindRepositoryV2 ==
292
256
            self._request_class):
293
257
            # All tests so far are on formats, and for non-external
294
258
            # repositories.
295
 
            return smart_req.SuccessfulSmartServerResponse(
296
 
                ('ok', '', rich_root, subtrees, external))
 
259
            return SuccessfulSmartServerResponse(
 
260
                ('ok', '', rich_root, subtrees, 'no'))
297
261
        else:
298
 
            return smart_req.SuccessfulSmartServerResponse(
299
 
                ('ok', '', rich_root, subtrees))
 
262
            return SuccessfulSmartServerResponse(('ok', '', rich_root, subtrees))
300
263
 
301
264
    def test_shared_repository(self):
302
265
        """When there is a shared repository, we get 'ok', 'relpath-to-repo'."""
305
268
        result = self._make_repository_and_result(shared=True)
306
269
        self.assertEqual(result, request.execute(''))
307
270
        self.make_bzrdir('subdir')
308
 
        result2 = smart_req.SmartServerResponse(
309
 
            result.args[0:1] + ('..', ) + result.args[2:])
 
271
        result2 = SmartServerResponse(result.args[0:1] + ('..', ) + result.args[2:])
310
272
        self.assertEqual(result2,
311
273
            request.execute('subdir'))
312
274
        self.make_bzrdir('subdir/deeper')
313
 
        result3 = smart_req.SmartServerResponse(
314
 
            result.args[0:1] + ('../..', ) + result.args[2:])
 
275
        result3 = SmartServerResponse(result.args[0:1] + ('../..', ) + result.args[2:])
315
276
        self.assertEqual(result3,
316
277
            request.execute('subdir/deeper'))
317
278
 
319
280
        """Test for the format attributes for rich root and subtree support."""
320
281
        backing = self.get_transport()
321
282
        request = self._request_class(backing)
322
 
        result = self._make_repository_and_result(
323
 
            format='dirstate-with-subtree')
 
283
        result = self._make_repository_and_result(format='dirstate-with-subtree')
324
284
        # check the test will be valid
325
285
        self.assertEqual('yes', result.args[2])
326
286
        self.assertEqual('yes', result.args[3])
330
290
        """Test for the supports_external_lookups attribute."""
331
291
        backing = self.get_transport()
332
292
        request = self._request_class(backing)
333
 
        result = self._make_repository_and_result(
334
 
            format='dirstate-with-subtree')
 
293
        result = self._make_repository_and_result(format='dirstate-with-subtree')
335
294
        # check the test will be valid
336
295
        self.assertEqual('no', result.args[4])
337
296
        self.assertEqual(result, request.execute(''))
338
297
 
339
298
 
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
299
class TestSmartServerRequestInitializeBzrDir(tests.TestCaseWithMemoryTransport):
364
300
 
365
301
    def test_empty_dir(self):
366
302
        """Initializing an empty dir should succeed and do it."""
367
303
        backing = self.get_transport()
368
 
        request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
369
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )),
 
304
        request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
 
305
        self.assertEqual(SmartServerResponse(('ok', )),
370
306
            request.execute(''))
371
307
        made_dir = bzrdir.BzrDir.open_from_transport(backing)
372
308
        # no branch, tree or repository is expected with the current
378
314
    def test_missing_dir(self):
379
315
        """Initializing a missing directory should fail like the bzrdir api."""
380
316
        backing = self.get_transport()
381
 
        request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
 
317
        request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
382
318
        self.assertRaises(errors.NoSuchFile,
383
319
            request.execute, 'subdir')
384
320
 
385
321
    def test_initialized_dir(self):
386
322
        """Initializing an extant bzrdir should fail like the bzrdir api."""
387
323
        backing = self.get_transport()
388
 
        request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
 
324
        request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
389
325
        self.make_bzrdir('subdir')
390
326
        self.assertRaises(errors.FileExists,
391
327
            request.execute, 'subdir')
392
328
 
393
329
 
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
330
class TestSmartServerRequestOpenBranch(TestCaseWithChrootedTransport):
504
331
 
505
332
    def test_no_branch(self):
506
333
        """When there is no branch, ('nobranch', ) is returned."""
507
334
        backing = self.get_transport()
508
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
 
335
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
509
336
        self.make_bzrdir('.')
510
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
 
337
        self.assertEqual(SmartServerResponse(('nobranch', )),
511
338
            request.execute(''))
512
339
 
513
340
    def test_branch(self):
514
341
        """When there is a branch, 'ok' is returned."""
515
342
        backing = self.get_transport()
516
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
 
343
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
517
344
        self.make_branch('.')
518
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', '')),
 
345
        self.assertEqual(SmartServerResponse(('ok', '')),
519
346
            request.execute(''))
520
347
 
521
348
    def test_branch_reference(self):
522
349
        """When there is a branch reference, the reference URL is returned."""
523
 
        self.vfs_transport_factory = test_server.LocalURLServer
524
350
        backing = self.get_transport()
525
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
 
351
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
526
352
        branch = self.make_branch('branch')
527
353
        checkout = branch.create_checkout('reference',lightweight=True)
528
 
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
529
 
            checkout.bzrdir)
 
354
        reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
530
355
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
531
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', reference_url)),
 
356
        self.assertEqual(SmartServerResponse(('ok', reference_url)),
532
357
            request.execute('reference'))
533
358
 
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
359
 
543
360
class TestSmartServerRequestOpenBranchV2(TestCaseWithChrootedTransport):
544
361
 
546
363
        """When there is no branch, ('nobranch', ) is returned."""
547
364
        backing = self.get_transport()
548
365
        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(''))
 
366
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
367
        self.assertEqual(SmartServerResponse(('nobranch', )),
 
368
            request.execute(''))
 
369
 
 
370
    def test_branch(self):
 
371
        """When there is a branch, 'ok' is returned."""
 
372
        backing = self.get_transport()
 
373
        expected = self.make_branch('.')._format.network_name()
 
374
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
375
        self.assertEqual(SuccessfulSmartServerResponse(('branch', expected)),
 
376
            request.execute(''))
 
377
 
 
378
    def test_branch_reference(self):
 
379
        """When there is a branch reference, the reference URL is returned."""
 
380
        backing = self.get_transport()
 
381
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
382
        branch = self.make_branch('branch')
 
383
        checkout = branch.create_checkout('reference',lightweight=True)
 
384
        reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
 
385
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
 
386
        self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
 
387
            request.execute('reference'))
 
388
 
 
389
    def test_stacked_branch(self):
 
390
        """Opening a stacked branch does not open the stacked-on branch."""
 
391
        trunk = self.make_branch('trunk')
 
392
        feature = self.make_branch('feature', format='1.9')
 
393
        feature.set_stacked_on_url(trunk.base)
 
394
        opened_branches = []
 
395
        Branch.hooks.install_named_hook('open', opened_branches.append, None)
 
396
        backing = self.get_transport()
 
397
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
398
        request.setup_jail()
 
399
        try:
 
400
            response = request.execute('feature')
 
401
        finally:
 
402
            request.teardown_jail()
 
403
        expected_format = feature._format.network_name()
 
404
        self.assertEqual(
 
405
            SuccessfulSmartServerResponse(('branch', expected_format)),
 
406
            response)
 
407
        self.assertLength(1, opened_branches)
668
408
 
669
409
 
670
410
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
672
412
    def test_empty(self):
673
413
        """For an empty branch, the body is empty."""
674
414
        backing = self.get_transport()
675
 
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
 
415
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
676
416
        self.make_branch('.')
677
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), ''),
 
417
        self.assertEqual(SmartServerResponse(('ok', ), ''),
678
418
            request.execute(''))
679
419
 
680
420
    def test_not_empty(self):
681
421
        """For a non-empty branch, the body is empty."""
682
422
        backing = self.get_transport()
683
 
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
 
423
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
684
424
        tree = self.make_branch_and_memory_tree('.')
685
425
        tree.lock_write()
686
426
        tree.add('')
688
428
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
689
429
        tree.unlock()
690
430
        self.assertEqual(
691
 
            smart_req.SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
 
431
            SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
692
432
            request.execute(''))
693
433
 
694
434
 
697
437
    def test_no_branch(self):
698
438
        """When there is a bzrdir and no branch, NotBranchError is raised."""
699
439
        backing = self.get_transport()
700
 
        request = smart_branch.SmartServerBranchRequest(backing)
 
440
        request = smart.branch.SmartServerBranchRequest(backing)
701
441
        self.make_bzrdir('.')
702
442
        self.assertRaises(errors.NotBranchError,
703
443
            request.execute, '')
705
445
    def test_branch_reference(self):
706
446
        """When there is a branch reference, NotBranchError is raised."""
707
447
        backing = self.get_transport()
708
 
        request = smart_branch.SmartServerBranchRequest(backing)
 
448
        request = smart.branch.SmartServerBranchRequest(backing)
709
449
        branch = self.make_branch('branch')
710
450
        checkout = branch.create_checkout('reference',lightweight=True)
711
451
        self.assertRaises(errors.NotBranchError,
712
452
            request.execute, 'checkout')
713
453
 
714
454
 
715
 
class TestSmartServerBranchRequestLastRevisionInfo(
716
 
    tests.TestCaseWithMemoryTransport):
 
455
class TestSmartServerBranchRequestLastRevisionInfo(tests.TestCaseWithMemoryTransport):
717
456
 
718
457
    def test_empty(self):
719
458
        """For an empty branch, the result is ('ok', '0', 'null:')."""
720
459
        backing = self.get_transport()
721
 
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
460
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
722
461
        self.make_branch('.')
723
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', '0', 'null:')),
 
462
        self.assertEqual(SmartServerResponse(('ok', '0', 'null:')),
724
463
            request.execute(''))
725
464
 
726
465
    def test_not_empty(self):
727
466
        """For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
728
467
        backing = self.get_transport()
729
 
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
468
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
730
469
        tree = self.make_branch_and_memory_tree('.')
731
470
        tree.lock_write()
732
471
        tree.add('')
735
474
        r2 = tree.commit('2nd commit', rev_id=rev_id_utf8)
736
475
        tree.unlock()
737
476
        self.assertEqual(
738
 
            smart_req.SmartServerResponse(('ok', '2', rev_id_utf8)),
 
477
            SmartServerResponse(('ok', '2', rev_id_utf8)),
739
478
            request.execute(''))
740
479
 
741
480
 
742
 
class TestSmartServerBranchRequestGetConfigFile(
743
 
    tests.TestCaseWithMemoryTransport):
 
481
class TestSmartServerBranchRequestGetConfigFile(tests.TestCaseWithMemoryTransport):
744
482
 
745
483
    def test_default(self):
746
484
        """With no file, we get empty content."""
747
485
        backing = self.get_transport()
748
 
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
 
486
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
749
487
        branch = self.make_branch('.')
750
488
        # there should be no file by default
751
489
        content = ''
752
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), content),
 
490
        self.assertEqual(SmartServerResponse(('ok', ), content),
753
491
            request.execute(''))
754
492
 
755
493
    def test_with_content(self):
757
495
        # branch.control_files.get('branch.conf') for now - in the future it may
758
496
        # perform more complex processing.
759
497
        backing = self.get_transport()
760
 
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
 
498
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
761
499
        branch = self.make_branch('.')
762
500
        branch._transport.put_bytes('branch.conf', 'foo bar baz')
763
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'foo bar baz'),
 
501
        self.assertEqual(SmartServerResponse(('ok', ), 'foo bar baz'),
764
502
            request.execute(''))
765
503
 
766
504
 
777
515
 
778
516
    def test_value_name(self):
779
517
        branch = self.make_branch('.')
780
 
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
 
518
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
781
519
            branch.bzrdir.root_transport)
782
520
        branch_token, repo_token = self.get_lock_tokens(branch)
783
521
        config = branch._get_config()
784
522
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
785
523
            '')
786
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
524
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
787
525
        self.assertEqual('bar', config.get_option('foo'))
788
 
        # Cleanup
789
 
        branch.unlock()
790
526
 
791
527
    def test_value_name_section(self):
792
528
        branch = self.make_branch('.')
793
 
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
 
529
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
794
530
            branch.bzrdir.root_transport)
795
531
        branch_token, repo_token = self.get_lock_tokens(branch)
796
532
        config = branch._get_config()
797
533
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
798
534
            'gam')
799
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
535
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
800
536
        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
537
 
841
538
 
842
539
class SetLastRevisionTestBase(TestLockedBranch):
863
560
 
864
561
    def assertRequestSucceeds(self, revision_id, revno):
865
562
        response = self.set_last_revision(revision_id, revno)
866
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
867
 
                         response)
 
563
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)), response)
868
564
 
869
565
 
870
566
class TestSetLastRevisionVerbMixin(object):
878
574
        """If the revision_id is not present, the verb returns NoSuchRevision.
879
575
        """
880
576
        revision_id = 'non-existent revision'
881
 
        self.assertEqual(smart_req.FailedSmartServerResponse(('NoSuchRevision',
882
 
                                                              revision_id)),
883
 
                         self.set_last_revision(revision_id, 1))
 
577
        self.assertEqual(
 
578
            FailedSmartServerResponse(('NoSuchRevision', revision_id)),
 
579
            self.set_last_revision(revision_id, 1))
884
580
 
885
581
    def make_tree_with_two_commits(self):
886
582
        self.tree.lock_write()
926
622
        rejection_message = u'rejection message\N{INTERROBANG}'
927
623
        def hook_that_rejects(params):
928
624
            raise errors.TipChangeRejected(rejection_message)
929
 
        _mod_branch.Branch.hooks.install_named_hook(
 
625
        Branch.hooks.install_named_hook(
930
626
            'pre_change_branch_tip', hook_that_rejects, None)
931
627
        self.assertEqual(
932
 
            smart_req.FailedSmartServerResponse(
 
628
            FailedSmartServerResponse(
933
629
                ('TipChangeRejected', rejection_message.encode('utf-8'))),
934
630
            self.set_last_revision('null:', 0))
935
631
 
938
634
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
939
635
    """Tests for Branch.set_last_revision verb."""
940
636
 
941
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevision
 
637
    request_class = smart.branch.SmartServerBranchRequestSetLastRevision
942
638
 
943
639
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
944
640
        return self.request.execute(
949
645
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
950
646
    """Tests for Branch.set_last_revision_info verb."""
951
647
 
952
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionInfo
 
648
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionInfo
953
649
 
954
650
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
955
651
        return self.request.execute(
966
662
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
967
663
    """Tests for Branch.set_last_revision_ex verb."""
968
664
 
969
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionEx
 
665
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionEx
970
666
 
971
667
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
972
668
        return self.request.execute(
975
671
    def assertRequestSucceeds(self, revision_id, revno):
976
672
        response = self.set_last_revision(revision_id, revno)
977
673
        self.assertEqual(
978
 
            smart_req.SuccessfulSmartServerResponse(('ok', revno, revision_id)),
 
674
            SuccessfulSmartServerResponse(('ok', revno, revision_id)),
979
675
            response)
980
676
 
981
677
    def test_branch_last_revision_info_rewind(self):
992
688
        response = self.request.execute(
993
689
            '', branch_token, repo_token, rev_id_utf8, 0, 0)
994
690
        self.assertEqual(
995
 
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
 
691
            SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
996
692
            response)
997
693
        self.assertEqual(
998
694
            (2, 'rev-2'), self.tree.branch.last_revision_info())
1002
698
        response = self.request.execute(
1003
699
            '', branch_token, repo_token, rev_id_utf8, 0, 1)
1004
700
        self.assertEqual(
1005
 
            smart_req.SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
 
701
            SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
1006
702
            response)
1007
703
        self.unlock_branch()
1008
704
        self.assertEqual(
1033
729
        """
1034
730
        self.make_branch_with_divergent_history()
1035
731
        self.assertEqual(
1036
 
            smart_req.FailedSmartServerResponse(('Diverged',)),
 
732
            FailedSmartServerResponse(('Diverged',)),
1037
733
            self.set_last_revision('child-1', 2))
1038
734
        # The branch tip was not changed.
1039
735
        self.assertEqual('child-2', self.tree.branch.last_revision())
1047
743
        response = self.request.execute(
1048
744
            '', branch_token, repo_token, 'child-1', 1, 0)
1049
745
        self.assertEqual(
1050
 
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
 
746
            SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
1051
747
            response)
1052
748
        self.unlock_branch()
1053
749
        # The branch tip was changed.
1058
754
 
1059
755
    def test_get_parent_none(self):
1060
756
        base_branch = self.make_branch('base')
1061
 
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
 
757
        request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1062
758
        response = request.execute('base')
1063
759
        self.assertEquals(
1064
 
            smart_req.SuccessfulSmartServerResponse(('',)), response)
 
760
            SuccessfulSmartServerResponse(('',)), response)
1065
761
 
1066
762
    def test_get_parent_something(self):
1067
763
        base_branch = self.make_branch('base')
1068
764
        base_branch.set_parent(self.get_url('foo'))
1069
 
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
 
765
        request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1070
766
        response = request.execute('base')
1071
767
        self.assertEquals(
1072
 
            smart_req.SuccessfulSmartServerResponse(("../foo",)),
 
768
            SuccessfulSmartServerResponse(("../foo",)),
1073
769
            response)
1074
770
 
1075
771
 
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.
 
772
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
 
773
# Only called when the branch format and tags match [yay factory
 
774
# methods] so only need to test straight forward cases.
1115
775
 
1116
776
    def test_get_bytes(self):
1117
777
        base_branch = self.make_branch('base')
1118
 
        request = smart_branch.SmartServerBranchGetTagsBytes(
 
778
        request = smart.branch.SmartServerBranchGetTagsBytes(
1119
779
            self.get_transport())
1120
780
        response = request.execute('base')
1121
781
        self.assertEquals(
1122
 
            smart_req.SuccessfulSmartServerResponse(('',)), response)
 
782
            SuccessfulSmartServerResponse(('',)), response)
1123
783
 
1124
784
 
1125
785
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
1129
789
        stacked_branch = self.make_branch('stacked', format='1.6')
1130
790
        # typically should be relative
1131
791
        stacked_branch.set_stacked_on_url('../base')
1132
 
        request = smart_branch.SmartServerBranchRequestGetStackedOnURL(
 
792
        request = smart.branch.SmartServerBranchRequestGetStackedOnURL(
1133
793
            self.get_transport())
1134
794
        response = request.execute('stacked')
1135
795
        self.assertEquals(
1136
 
            smart_req.SmartServerResponse(('ok', '../base')),
 
796
            SmartServerResponse(('ok', '../base')),
1137
797
            response)
1138
798
 
1139
799
 
1144
804
 
1145
805
    def test_lock_write_on_unlocked_branch(self):
1146
806
        backing = self.get_transport()
1147
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
807
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1148
808
        branch = self.make_branch('.', format='knit')
1149
809
        repository = branch.repository
1150
810
        response = request.execute('')
1151
811
        branch_nonce = branch.control_files._lock.peek().get('nonce')
1152
812
        repository_nonce = repository.control_files._lock.peek().get('nonce')
1153
 
        self.assertEqual(smart_req.SmartServerResponse(
1154
 
                ('ok', branch_nonce, repository_nonce)),
1155
 
                         response)
 
813
        self.assertEqual(
 
814
            SmartServerResponse(('ok', branch_nonce, repository_nonce)),
 
815
            response)
1156
816
        # The branch (and associated repository) is now locked.  Verify that
1157
817
        # with a new branch object.
1158
818
        new_branch = repository.bzrdir.open_branch()
1159
819
        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
820
 
1164
821
    def test_lock_write_on_locked_branch(self):
1165
822
        backing = self.get_transport()
1166
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
823
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1167
824
        branch = self.make_branch('.')
1168
 
        branch_token = branch.lock_write()
 
825
        branch.lock_write()
1169
826
        branch.leave_lock_in_place()
1170
827
        branch.unlock()
1171
828
        response = request.execute('')
1172
829
        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()
 
830
            SmartServerResponse(('LockContention',)), response)
1178
831
 
1179
832
    def test_lock_write_with_tokens_on_locked_branch(self):
1180
833
        backing = self.get_transport()
1181
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
834
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1182
835
        branch = self.make_branch('.', format='knit')
1183
836
        branch_token = branch.lock_write()
1184
837
        repo_token = branch.repository.lock_write()
1189
842
        response = request.execute('',
1190
843
                                   branch_token, repo_token)
1191
844
        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()
 
845
            SmartServerResponse(('ok', branch_token, repo_token)), response)
1201
846
 
1202
847
    def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
1203
848
        backing = self.get_transport()
1204
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
849
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1205
850
        branch = self.make_branch('.', format='knit')
1206
851
        branch_token = branch.lock_write()
1207
852
        repo_token = branch.repository.lock_write()
1212
857
        response = request.execute('',
1213
858
                                   branch_token+'xxx', repo_token)
1214
859
        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()
 
860
            SmartServerResponse(('TokenMismatch',)), response)
1223
861
 
1224
862
    def test_lock_write_on_locked_repo(self):
1225
863
        backing = self.get_transport()
1226
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
864
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1227
865
        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()
 
866
        branch.repository.lock_write()
 
867
        branch.repository.leave_lock_in_place()
 
868
        branch.repository.unlock()
1232
869
        response = request.execute('')
1233
870
        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()
 
871
            SmartServerResponse(('LockContention',)), response)
1239
872
 
1240
873
    def test_lock_write_on_readonly_transport(self):
1241
874
        backing = self.get_readonly_transport()
1242
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
875
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1243
876
        branch = self.make_branch('.')
1244
877
        root = self.get_transport().clone('/')
1245
878
        path = urlutils.relative_url(root.base, self.get_transport().base)
1256
889
 
1257
890
    def test_unlock_on_locked_branch_and_repo(self):
1258
891
        backing = self.get_transport()
1259
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
892
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1260
893
        branch = self.make_branch('.', format='knit')
1261
894
        # Lock the branch
1262
895
        branch_token = branch.lock_write()
1270
903
        response = request.execute('',
1271
904
                                   branch_token, repo_token)
1272
905
        self.assertEqual(
1273
 
            smart_req.SmartServerResponse(('ok',)), response)
 
906
            SmartServerResponse(('ok',)), response)
1274
907
        # The branch is now unlocked.  Verify that with a new branch
1275
908
        # object.
1276
909
        new_branch = branch.bzrdir.open_branch()
1279
912
 
1280
913
    def test_unlock_on_unlocked_branch_unlocked_repo(self):
1281
914
        backing = self.get_transport()
1282
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
915
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1283
916
        branch = self.make_branch('.', format='knit')
1284
917
        response = request.execute(
1285
918
            '', 'branch token', 'repo token')
1286
919
        self.assertEqual(
1287
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
920
            SmartServerResponse(('TokenMismatch',)), response)
1288
921
 
1289
922
    def test_unlock_on_unlocked_branch_locked_repo(self):
1290
923
        backing = self.get_transport()
1291
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
924
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1292
925
        branch = self.make_branch('.', format='knit')
1293
926
        # Lock the repository.
1294
927
        repo_token = branch.repository.lock_write()
1299
932
        response = request.execute(
1300
933
            '', 'branch token', repo_token)
1301
934
        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()
 
935
            SmartServerResponse(('TokenMismatch',)), response)
1307
936
 
1308
937
 
1309
938
class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport):
1315
944
        # its the exact path being looked at and the server is not
1316
945
        # searching.
1317
946
        backing = self.get_transport()
1318
 
        request = smart_repo.SmartServerRepositoryRequest(backing)
 
947
        request = smart.repository.SmartServerRepositoryRequest(backing)
1319
948
        self.make_repository('.', shared=True)
1320
949
        self.make_bzrdir('subdir')
1321
950
        self.assertRaises(errors.NoRepositoryPresent,
1327
956
    def test_trivial_bzipped(self):
1328
957
        # This tests that the wire encoding is actually bzipped
1329
958
        backing = self.get_transport()
1330
 
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
 
959
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1331
960
        tree = self.make_branch_and_memory_tree('.')
1332
961
 
1333
962
        self.assertEqual(None,
1334
963
            request.execute('', 'missing-id'))
1335
964
        # Note that it returns a body that is bzipped.
1336
965
        self.assertEqual(
1337
 
            smart_req.SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
 
966
            SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1338
967
            request.do_body('\n\n0\n'))
1339
968
 
1340
969
    def test_trivial_include_missing(self):
1341
970
        backing = self.get_transport()
1342
 
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
 
971
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1343
972
        tree = self.make_branch_and_memory_tree('.')
1344
973
 
1345
974
        self.assertEqual(None,
1346
975
            request.execute('', 'missing-id', 'include-missing:'))
1347
976
        self.assertEqual(
1348
 
            smart_req.SuccessfulSmartServerResponse(('ok', ),
 
977
            SuccessfulSmartServerResponse(('ok', ),
1349
978
                bz2.compress('missing:missing-id')),
1350
979
            request.do_body('\n\n0\n'))
1351
980
 
1352
981
 
1353
 
class TestSmartServerRepositoryGetRevisionGraph(
1354
 
    tests.TestCaseWithMemoryTransport):
 
982
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
1355
983
 
1356
984
    def test_none_argument(self):
1357
985
        backing = self.get_transport()
1358
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
986
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1359
987
        tree = self.make_branch_and_memory_tree('.')
1360
988
        tree.lock_write()
1361
989
        tree.add('')
1370
998
        response.body = '\n'.join(sorted(response.body.split('\n')))
1371
999
 
1372
1000
        self.assertEqual(
1373
 
            smart_req.SmartServerResponse(('ok', ), '\n'.join(lines)), response)
 
1001
            SmartServerResponse(('ok', ), '\n'.join(lines)), response)
1374
1002
 
1375
1003
    def test_specific_revision_argument(self):
1376
1004
        backing = self.get_transport()
1377
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1005
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1378
1006
        tree = self.make_branch_and_memory_tree('.')
1379
1007
        tree.lock_write()
1380
1008
        tree.add('')
1383
1011
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1384
1012
        tree.unlock()
1385
1013
 
1386
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), rev_id_utf8),
 
1014
        self.assertEqual(SmartServerResponse(('ok', ), rev_id_utf8),
1387
1015
            request.execute('', rev_id_utf8))
1388
1016
 
1389
1017
    def test_no_such_revision(self):
1390
1018
        backing = self.get_transport()
1391
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1019
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1392
1020
        tree = self.make_branch_and_memory_tree('.')
1393
1021
        tree.lock_write()
1394
1022
        tree.add('')
1396
1024
        tree.unlock()
1397
1025
 
1398
1026
        # 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)))
 
1027
        self.assertEqual(
 
1028
            SmartServerResponse(('nosuchrevision', 'missingrevision', ), ''),
 
1029
            request.execute('', 'missingrevision'))
1448
1030
 
1449
1031
 
1450
1032
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1462
1044
    def test_ancestry_of(self):
1463
1045
        """The search argument may be a 'ancestry-of' some heads'."""
1464
1046
        backing = self.get_transport()
1465
 
        request = smart_repo.SmartServerRepositoryGetStream(backing)
 
1047
        request = smart.repository.SmartServerRepositoryGetStream(backing)
1466
1048
        repo, r1, r2 = self.make_two_commit_repo()
1467
1049
        fetch_spec = ['ancestry-of', r2]
1468
1050
        lines = '\n'.join(fetch_spec)
1475
1057
    def test_search(self):
1476
1058
        """The search argument may be a 'search' of some explicit keys."""
1477
1059
        backing = self.get_transport()
1478
 
        request = smart_repo.SmartServerRepositoryGetStream(backing)
 
1060
        request = smart.repository.SmartServerRepositoryGetStream(backing)
1479
1061
        repo, r1, r2 = self.make_two_commit_repo()
1480
1062
        fetch_spec = ['search', '%s %s' % (r1, r2), 'null:', '2']
1481
1063
        lines = '\n'.join(fetch_spec)
1491
1073
    def test_missing_revision(self):
1492
1074
        """For a missing revision, ('no', ) is returned."""
1493
1075
        backing = self.get_transport()
1494
 
        request = smart_repo.SmartServerRequestHasRevision(backing)
 
1076
        request = smart.repository.SmartServerRequestHasRevision(backing)
1495
1077
        self.make_repository('.')
1496
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1078
        self.assertEqual(SmartServerResponse(('no', )),
1497
1079
            request.execute('', 'revid'))
1498
1080
 
1499
1081
    def test_present_revision(self):
1500
1082
        """For a present revision, ('yes', ) is returned."""
1501
1083
        backing = self.get_transport()
1502
 
        request = smart_repo.SmartServerRequestHasRevision(backing)
 
1084
        request = smart.repository.SmartServerRequestHasRevision(backing)
1503
1085
        tree = self.make_branch_and_memory_tree('.')
1504
1086
        tree.lock_write()
1505
1087
        tree.add('')
1507
1089
        r1 = tree.commit('a commit', rev_id=rev_id_utf8)
1508
1090
        tree.unlock()
1509
1091
        self.assertTrue(tree.branch.repository.has_revision(rev_id_utf8))
1510
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1092
        self.assertEqual(SmartServerResponse(('yes', )),
1511
1093
            request.execute('', rev_id_utf8))
1512
1094
 
1513
1095
 
1516
1098
    def test_empty_revid(self):
1517
1099
        """With an empty revid, we get only size an number and revisions"""
1518
1100
        backing = self.get_transport()
1519
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1101
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1520
1102
        repository = self.make_repository('.')
1521
1103
        stats = repository.gather_stats()
1522
1104
        expected_body = 'revisions: 0\n'
1523
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1105
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1524
1106
                         request.execute('', '', 'no'))
1525
1107
 
1526
1108
    def test_revid_with_committers(self):
1527
1109
        """For a revid we get more infos."""
1528
1110
        backing = self.get_transport()
1529
1111
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1530
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1112
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1531
1113
        tree = self.make_branch_and_memory_tree('.')
1532
1114
        tree.lock_write()
1533
1115
        tree.add('')
1541
1123
        expected_body = ('firstrev: 123456.200 3600\n'
1542
1124
                         'latestrev: 654321.400 0\n'
1543
1125
                         'revisions: 2\n')
1544
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1126
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1545
1127
                         request.execute('',
1546
1128
                                         rev_id_utf8, 'no'))
1547
1129
 
1549
1131
        """For a revid and requesting committers we get the whole thing."""
1550
1132
        backing = self.get_transport()
1551
1133
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1552
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1134
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1553
1135
        tree = self.make_branch_and_memory_tree('.')
1554
1136
        tree.lock_write()
1555
1137
        tree.add('')
1565
1147
                         'firstrev: 123456.200 3600\n'
1566
1148
                         'latestrev: 654321.400 0\n'
1567
1149
                         'revisions: 2\n')
1568
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1150
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1569
1151
                         request.execute('',
1570
1152
                                         rev_id_utf8, 'yes'))
1571
1153
 
1575
1157
    def test_is_shared(self):
1576
1158
        """For a shared repository, ('yes', ) is returned."""
1577
1159
        backing = self.get_transport()
1578
 
        request = smart_repo.SmartServerRepositoryIsShared(backing)
 
1160
        request = smart.repository.SmartServerRepositoryIsShared(backing)
1579
1161
        self.make_repository('.', shared=True)
1580
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1162
        self.assertEqual(SmartServerResponse(('yes', )),
1581
1163
            request.execute('', ))
1582
1164
 
1583
1165
    def test_is_not_shared(self):
1584
1166
        """For a shared repository, ('no', ) is returned."""
1585
1167
        backing = self.get_transport()
1586
 
        request = smart_repo.SmartServerRepositoryIsShared(backing)
 
1168
        request = smart.repository.SmartServerRepositoryIsShared(backing)
1587
1169
        self.make_repository('.', shared=False)
1588
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1170
        self.assertEqual(SmartServerResponse(('no', )),
1589
1171
            request.execute('', ))
1590
1172
 
1591
1173
 
1593
1175
 
1594
1176
    def test_lock_write_on_unlocked_repo(self):
1595
1177
        backing = self.get_transport()
1596
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1178
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1597
1179
        repository = self.make_repository('.', format='knit')
1598
1180
        response = request.execute('')
1599
1181
        nonce = repository.control_files._lock.peek().get('nonce')
1600
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
 
1182
        self.assertEqual(SmartServerResponse(('ok', nonce)), response)
1601
1183
        # The repository is now locked.  Verify that with a new repository
1602
1184
        # object.
1603
1185
        new_repo = repository.bzrdir.open_repository()
1604
1186
        self.assertRaises(errors.LockContention, new_repo.lock_write)
1605
 
        # Cleanup
1606
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
1607
 
        response = request.execute('', nonce)
1608
1187
 
1609
1188
    def test_lock_write_on_locked_repo(self):
1610
1189
        backing = self.get_transport()
1611
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1190
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1612
1191
        repository = self.make_repository('.', format='knit')
1613
 
        repo_token = repository.lock_write()
 
1192
        repository.lock_write()
1614
1193
        repository.leave_lock_in_place()
1615
1194
        repository.unlock()
1616
1195
        response = request.execute('')
1617
1196
        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()
 
1197
            SmartServerResponse(('LockContention',)), response)
1623
1198
 
1624
1199
    def test_lock_write_on_readonly_transport(self):
1625
1200
        backing = self.get_readonly_transport()
1626
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1201
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1627
1202
        repository = self.make_repository('.', format='knit')
1628
1203
        response = request.execute('')
1629
1204
        self.assertFalse(response.is_successful())
1633
1208
class TestInsertStreamBase(tests.TestCaseWithMemoryTransport):
1634
1209
 
1635
1210
    def make_empty_byte_stream(self, repo):
1636
 
        byte_stream = smart_repo._stream_to_byte_stream([], repo._format)
 
1211
        byte_stream = smart.repository._stream_to_byte_stream([], repo._format)
1637
1212
        return ''.join(byte_stream)
1638
1213
 
1639
1214
 
1641
1216
 
1642
1217
    def test_insert_stream_empty(self):
1643
1218
        backing = self.get_transport()
1644
 
        request = smart_repo.SmartServerRepositoryInsertStream(backing)
 
1219
        request = smart.repository.SmartServerRepositoryInsertStream(backing)
1645
1220
        repository = self.make_repository('.')
1646
1221
        response = request.execute('', '')
1647
1222
        self.assertEqual(None, response)
1648
1223
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1649
1224
        self.assertEqual(None, response)
1650
1225
        response = request.do_end()
1651
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1652
 
 
 
1226
        self.assertEqual(SmartServerResponse(('ok', )), response)
 
1227
        
1653
1228
 
1654
1229
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
1655
1230
 
1656
1231
    def test_insert_stream_empty(self):
1657
1232
        backing = self.get_transport()
1658
 
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
 
1233
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1659
1234
            backing)
1660
1235
        repository = self.make_repository('.', format='knit')
1661
1236
        lock_token = repository.lock_write()
1664
1239
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1665
1240
        self.assertEqual(None, response)
1666
1241
        response = request.do_end()
1667
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
 
1242
        self.assertEqual(SmartServerResponse(('ok', )), response)
1668
1243
        repository.unlock()
1669
1244
 
1670
1245
    def test_insert_stream_with_wrong_lock_token(self):
1671
1246
        backing = self.get_transport()
1672
 
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
 
1247
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1673
1248
            backing)
1674
1249
        repository = self.make_repository('.', format='knit')
1675
1250
        lock_token = repository.lock_write()
1685
1260
 
1686
1261
    def test_unlock_on_locked_repo(self):
1687
1262
        backing = self.get_transport()
1688
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1263
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1689
1264
        repository = self.make_repository('.', format='knit')
1690
1265
        token = repository.lock_write()
1691
1266
        repository.leave_lock_in_place()
1692
1267
        repository.unlock()
1693
1268
        response = request.execute('', token)
1694
1269
        self.assertEqual(
1695
 
            smart_req.SmartServerResponse(('ok',)), response)
 
1270
            SmartServerResponse(('ok',)), response)
1696
1271
        # The repository is now unlocked.  Verify that with a new repository
1697
1272
        # object.
1698
1273
        new_repo = repository.bzrdir.open_repository()
1701
1276
 
1702
1277
    def test_unlock_on_unlocked_repo(self):
1703
1278
        backing = self.get_transport()
1704
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1279
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1705
1280
        repository = self.make_repository('.', format='knit')
1706
1281
        response = request.execute('', 'some token')
1707
1282
        self.assertEqual(
1708
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1283
            SmartServerResponse(('TokenMismatch',)), response)
1709
1284
 
1710
1285
 
1711
1286
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1712
1287
 
1713
1288
    def test_is_readonly_no(self):
1714
1289
        backing = self.get_transport()
1715
 
        request = smart_req.SmartServerIsReadonly(backing)
 
1290
        request = smart.request.SmartServerIsReadonly(backing)
1716
1291
        response = request.execute()
1717
1292
        self.assertEqual(
1718
 
            smart_req.SmartServerResponse(('no',)), response)
 
1293
            SmartServerResponse(('no',)), response)
1719
1294
 
1720
1295
    def test_is_readonly_yes(self):
1721
1296
        backing = self.get_readonly_transport()
1722
 
        request = smart_req.SmartServerIsReadonly(backing)
 
1297
        request = smart.request.SmartServerIsReadonly(backing)
1723
1298
        response = request.execute()
1724
1299
        self.assertEqual(
1725
 
            smart_req.SmartServerResponse(('yes',)), response)
1726
 
 
1727
 
 
1728
 
class TestSmartServerRepositorySetMakeWorkingTrees(
1729
 
    tests.TestCaseWithMemoryTransport):
 
1300
            SmartServerResponse(('yes',)), response)
 
1301
 
 
1302
 
 
1303
class TestSmartServerRepositorySetMakeWorkingTrees(tests.TestCaseWithMemoryTransport):
1730
1304
 
1731
1305
    def test_set_false(self):
1732
1306
        backing = self.get_transport()
1733
1307
        repo = self.make_repository('.', shared=True)
1734
1308
        repo.set_make_working_trees(True)
1735
 
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
 
1309
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1736
1310
        request = request_class(backing)
1737
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1311
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1738
1312
            request.execute('', 'False'))
1739
1313
        repo = repo.bzrdir.open_repository()
1740
1314
        self.assertFalse(repo.make_working_trees())
1743
1317
        backing = self.get_transport()
1744
1318
        repo = self.make_repository('.', shared=True)
1745
1319
        repo.set_make_working_trees(False)
1746
 
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
 
1320
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1747
1321
        request = request_class(backing)
1748
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1322
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1749
1323
            request.execute('', 'True'))
1750
1324
        repo = repo.bzrdir.open_repository()
1751
1325
        self.assertTrue(repo.make_working_trees())
1770
1344
        repo.lock_write()
1771
1345
        self.addCleanup(repo.unlock)
1772
1346
        backing = self.get_transport()
1773
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1347
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1774
1348
            backing)
1775
1349
        response = request.execute('')
1776
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1350
        self.assertEqual(SmartServerResponse(('ok',)), response)
1777
1351
        repo._pack_collection.reload_pack_names()
1778
1352
        self.assertEqual(1, len(repo._pack_collection.names()))
1779
1353
 
1785
1359
        for x in range(9):
1786
1360
            tree.commit('commit %s' % x)
1787
1361
        backing = self.get_transport()
1788
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1362
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1789
1363
            backing)
1790
1364
        response = request.execute('')
1791
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1365
        self.assertEqual(SmartServerResponse(('ok',)), response)
1792
1366
        repo._pack_collection.reload_pack_names()
1793
1367
        self.assertEqual(9, len(repo._pack_collection.names()))
1794
1368
 
1796
1370
        """A request to autopack a non-pack repo is a no-op."""
1797
1371
        repo = self.make_repository('.', format='knit')
1798
1372
        backing = self.get_transport()
1799
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1373
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1800
1374
            backing)
1801
1375
        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))
 
1376
        self.assertEqual(SmartServerResponse(('ok',)), response)
1816
1377
 
1817
1378
 
1818
1379
class TestHandlers(tests.TestCase):
1822
1383
        """All registered request_handlers can be found."""
1823
1384
        # If there's a typo in a register_lazy call, this loop will fail with
1824
1385
        # an AttributeError.
1825
 
        for key, item in smart_req.request_handlers.iteritems():
 
1386
        for key, item in smart.request.request_handlers.iteritems():
1826
1387
            pass
1827
1388
 
1828
 
    def assertHandlerEqual(self, verb, handler):
1829
 
        self.assertEqual(smart_req.request_handlers.get(verb), handler)
1830
 
 
1831
1389
    def test_registered_methods(self):
1832
1390
        """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)
 
1391
        self.assertEqual(
 
1392
            smart.request.request_handlers.get('Branch.get_config_file'),
 
1393
            smart.branch.SmartServerBranchGetConfigFile)
 
1394
        self.assertEqual(
 
1395
            smart.request.request_handlers.get('Branch.get_parent'),
 
1396
            smart.branch.SmartServerBranchGetParent)
 
1397
        self.assertEqual(
 
1398
            smart.request.request_handlers.get('Branch.get_tags_bytes'),
 
1399
            smart.branch.SmartServerBranchGetTagsBytes)
 
1400
        self.assertEqual(
 
1401
            smart.request.request_handlers.get('Branch.lock_write'),
 
1402
            smart.branch.SmartServerBranchRequestLockWrite)
 
1403
        self.assertEqual(
 
1404
            smart.request.request_handlers.get('Branch.last_revision_info'),
 
1405
            smart.branch.SmartServerBranchRequestLastRevisionInfo)
 
1406
        self.assertEqual(
 
1407
            smart.request.request_handlers.get('Branch.revision_history'),
 
1408
            smart.branch.SmartServerRequestRevisionHistory)
 
1409
        self.assertEqual(
 
1410
            smart.request.request_handlers.get('Branch.set_config_option'),
 
1411
            smart.branch.SmartServerBranchRequestSetConfigOption)
 
1412
        self.assertEqual(
 
1413
            smart.request.request_handlers.get('Branch.set_last_revision'),
 
1414
            smart.branch.SmartServerBranchRequestSetLastRevision)
 
1415
        self.assertEqual(
 
1416
            smart.request.request_handlers.get('Branch.set_last_revision_info'),
 
1417
            smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
 
1418
        self.assertEqual(
 
1419
            smart.request.request_handlers.get('Branch.unlock'),
 
1420
            smart.branch.SmartServerBranchRequestUnlock)
 
1421
        self.assertEqual(
 
1422
            smart.request.request_handlers.get('BzrDir.find_repository'),
 
1423
            smart.bzrdir.SmartServerRequestFindRepositoryV1)
 
1424
        self.assertEqual(
 
1425
            smart.request.request_handlers.get('BzrDir.find_repositoryV2'),
 
1426
            smart.bzrdir.SmartServerRequestFindRepositoryV2)
 
1427
        self.assertEqual(
 
1428
            smart.request.request_handlers.get('BzrDirFormat.initialize'),
 
1429
            smart.bzrdir.SmartServerRequestInitializeBzrDir)
 
1430
        self.assertEqual(
 
1431
            smart.request.request_handlers.get('BzrDir.cloning_metadir'),
 
1432
            smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
 
1433
        self.assertEqual(
 
1434
            smart.request.request_handlers.get('BzrDir.open_branch'),
 
1435
            smart.bzrdir.SmartServerRequestOpenBranch)
 
1436
        self.assertEqual(
 
1437
            smart.request.request_handlers.get('BzrDir.open_branchV2'),
 
1438
            smart.bzrdir.SmartServerRequestOpenBranchV2)
 
1439
        self.assertEqual(
 
1440
            smart.request.request_handlers.get('PackRepository.autopack'),
 
1441
            smart.packrepository.SmartServerPackRepositoryAutopack)
 
1442
        self.assertEqual(
 
1443
            smart.request.request_handlers.get('Repository.gather_stats'),
 
1444
            smart.repository.SmartServerRepositoryGatherStats)
 
1445
        self.assertEqual(
 
1446
            smart.request.request_handlers.get('Repository.get_parent_map'),
 
1447
            smart.repository.SmartServerRepositoryGetParentMap)
 
1448
        self.assertEqual(
 
1449
            smart.request.request_handlers.get(
 
1450
                'Repository.get_revision_graph'),
 
1451
            smart.repository.SmartServerRepositoryGetRevisionGraph)
 
1452
        self.assertEqual(
 
1453
            smart.request.request_handlers.get('Repository.get_stream'),
 
1454
            smart.repository.SmartServerRepositoryGetStream)
 
1455
        self.assertEqual(
 
1456
            smart.request.request_handlers.get('Repository.has_revision'),
 
1457
            smart.repository.SmartServerRequestHasRevision)
 
1458
        self.assertEqual(
 
1459
            smart.request.request_handlers.get('Repository.insert_stream'),
 
1460
            smart.repository.SmartServerRepositoryInsertStream)
 
1461
        self.assertEqual(
 
1462
            smart.request.request_handlers.get('Repository.insert_stream_locked'),
 
1463
            smart.repository.SmartServerRepositoryInsertStreamLocked)
 
1464
        self.assertEqual(
 
1465
            smart.request.request_handlers.get('Repository.is_shared'),
 
1466
            smart.repository.SmartServerRepositoryIsShared)
 
1467
        self.assertEqual(
 
1468
            smart.request.request_handlers.get('Repository.lock_write'),
 
1469
            smart.repository.SmartServerRepositoryLockWrite)
 
1470
        self.assertEqual(
 
1471
            smart.request.request_handlers.get('Repository.tarball'),
 
1472
            smart.repository.SmartServerRepositoryTarball)
 
1473
        self.assertEqual(
 
1474
            smart.request.request_handlers.get('Repository.unlock'),
 
1475
            smart.repository.SmartServerRepositoryUnlock)
 
1476
        self.assertEqual(
 
1477
            smart.request.request_handlers.get('Transport.is_readonly'),
 
1478
            smart.request.SmartServerIsReadonly)