← 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: Martin Pool
  • Date: 2010-01-29 14:09:05 UTC
  • mto: This revision was merged to the branch mainline in revision 4992.
  • Revision ID: mbp@sourcefrog.net-20100129140905-2uiarb6p8di1ywsr
Correction to url

from review: https://code.edge.launchpad.net/~mbp/bzr/doc/+merge/18250

Show diffs side-by-side

added added

removed removed

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