← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: John Arbash Meinel
  • Date: 2010-01-13 16:23:07 UTC
  • mto: (4634.119.7 2.0)
  • mto: This revision was merged to the branch mainline in revision 4959.
  • Revision ID: john@arbash-meinel.com-20100113162307-0bs82td16gzih827
Update the MANIFEST.in file.

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