← 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: Jonathan Lange
  • Date: 2009-05-01 06:42:30 UTC
  • mto: This revision was merged to the branch mainline in revision 4320.
  • Revision ID: jml@canonical.com-20090501064230-kyk7v49xt8cevd25
Remove InstallFailed, it's not needed anymore.

Show diffs side-by-side

added added

removed removed

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