← 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: John Arbash Meinel
  • Date: 2010-08-13 19:08:57 UTC
  • mto: (5050.17.7 2.2)
  • mto: This revision was merged to the branch mainline in revision 5379.
  • Revision ID: john@arbash-meinel.com-20100813190857-mvzwnimrxvm0zimp
Lots of documentation updates.

We had a lot of http links pointing to the old domain. They should
all now be properly updated to the new domain. (only bazaar-vcs.org
entry left is for pqm, which seems to still reside at the old url.)

Also removed one 'TODO' doc entry about switching to binary xdelta, since
we basically did just that with groupcompress.

Show diffs side-by-side

added added

removed removed

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