/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Aaron Bentley
  • Date: 2009-04-23 21:32:09 UTC
  • mto: This revision was merged to the branch mainline in revision 4306.
  • Revision ID: aaron@aaronbentley.com-20090423213209-42p1s1p4p1unvvwi
Further cleanups

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.
397
 
 
398
 
    The main unit tests in test_bzrdir exercise the API comprehensively.
399
 
    """
400
 
 
401
 
    def test_empty_dir(self):
402
 
        """Initializing an empty dir should succeed and do it."""
403
 
        backing = self.get_transport()
404
 
        name = self.make_bzrdir('reference')._format.network_name()
405
 
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
406
 
        self.assertEqual(
407
 
            smart_req.SmartServerResponse(('', '', '', '', '', '', name,
408
 
                                           'False', '', '', '')),
409
 
            request.execute(name, '', 'True', 'False', 'False', '', '', '', '',
410
 
                            'False'))
411
 
        made_dir = bzrdir.BzrDir.open_from_transport(backing)
412
 
        # no branch, tree or repository is expected with the current
413
 
        # default format.
414
 
        self.assertRaises(errors.NoWorkingTree, made_dir.open_workingtree)
415
 
        self.assertRaises(errors.NotBranchError, made_dir.open_branch)
416
 
        self.assertRaises(errors.NoRepositoryPresent, made_dir.open_repository)
417
 
 
418
 
    def test_missing_dir(self):
419
 
        """Initializing a missing directory should fail like the bzrdir api."""
420
 
        backing = self.get_transport()
421
 
        name = self.make_bzrdir('reference')._format.network_name()
422
 
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
423
 
        self.assertRaises(errors.NoSuchFile, request.execute, name,
424
 
            'subdir/dir', 'False', 'False', 'False', '', '', '', '', 'False')
425
 
 
426
 
    def test_initialized_dir(self):
427
 
        """Initializing an extant directory should fail like the bzrdir api."""
428
 
        backing = self.get_transport()
429
 
        name = self.make_bzrdir('reference')._format.network_name()
430
 
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
431
 
        self.make_bzrdir('subdir')
432
 
        self.assertRaises(errors.FileExists, request.execute, name, 'subdir',
433
 
            'False', 'False', 'False', '', '', '', '', 'False')
434
 
 
435
 
 
436
 
class TestSmartServerRequestOpenBzrDir(tests.TestCaseWithMemoryTransport):
437
 
 
438
 
    def test_no_directory(self):
439
 
        backing = self.get_transport()
440
 
        request = smart_dir.SmartServerRequestOpenBzrDir(backing)
441
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
442
 
            request.execute('does-not-exist'))
443
 
 
444
 
    def test_empty_directory(self):
445
 
        backing = self.get_transport()
446
 
        backing.mkdir('empty')
447
 
        request = smart_dir.SmartServerRequestOpenBzrDir(backing)
448
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
449
 
            request.execute('empty'))
450
 
 
451
 
    def test_outside_root_client_path(self):
452
 
        backing = self.get_transport()
453
 
        request = smart_dir.SmartServerRequestOpenBzrDir(backing,
454
 
            root_client_path='root')
455
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
456
 
            request.execute('not-root'))
457
 
 
458
 
 
459
 
class TestSmartServerRequestOpenBzrDir_2_1(tests.TestCaseWithMemoryTransport):
460
 
 
461
 
    def test_no_directory(self):
462
 
        backing = self.get_transport()
463
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
464
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
465
 
            request.execute('does-not-exist'))
466
 
 
467
 
    def test_empty_directory(self):
468
 
        backing = self.get_transport()
469
 
        backing.mkdir('empty')
470
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
471
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
472
 
            request.execute('empty'))
473
 
 
474
 
    def test_present_without_workingtree(self):
475
 
        backing = self.get_transport()
476
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
477
 
        self.make_bzrdir('.')
478
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', 'no')),
479
 
            request.execute(''))
480
 
 
481
 
    def test_outside_root_client_path(self):
482
 
        backing = self.get_transport()
483
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing,
484
 
            root_client_path='root')
485
 
        self.assertEqual(smart_req.SmartServerResponse(('no',)),
486
 
            request.execute('not-root'))
487
 
 
488
 
 
489
 
class TestSmartServerRequestOpenBzrDir_2_1_disk(TestCaseWithChrootedTransport):
490
 
 
491
 
    def test_present_with_workingtree(self):
492
 
        self.vfs_transport_factory = test_server.LocalURLServer
493
 
        backing = self.get_transport()
494
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
495
 
        bd = self.make_bzrdir('.')
496
 
        bd.create_repository()
497
 
        bd.create_branch()
498
 
        bd.create_workingtree()
499
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', 'yes')),
500
 
            request.execute(''))
501
 
 
502
 
 
503
353
class TestSmartServerRequestOpenBranch(TestCaseWithChrootedTransport):
504
354
 
505
355
    def test_no_branch(self):
506
356
        """When there is no branch, ('nobranch', ) is returned."""
507
357
        backing = self.get_transport()
508
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
 
358
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
509
359
        self.make_bzrdir('.')
510
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
 
360
        self.assertEqual(SmartServerResponse(('nobranch', )),
511
361
            request.execute(''))
512
362
 
513
363
    def test_branch(self):
514
364
        """When there is a branch, 'ok' is returned."""
515
365
        backing = self.get_transport()
516
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
 
366
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
517
367
        self.make_branch('.')
518
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', '')),
 
368
        self.assertEqual(SmartServerResponse(('ok', '')),
519
369
            request.execute(''))
520
370
 
521
371
    def test_branch_reference(self):
522
372
        """When there is a branch reference, the reference URL is returned."""
523
 
        self.vfs_transport_factory = test_server.LocalURLServer
524
373
        backing = self.get_transport()
525
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
 
374
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
526
375
        branch = self.make_branch('branch')
527
376
        checkout = branch.create_checkout('reference',lightweight=True)
528
 
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
529
 
            checkout.bzrdir)
 
377
        reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
530
378
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
531
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', reference_url)),
 
379
        self.assertEqual(SmartServerResponse(('ok', reference_url)),
532
380
            request.execute('reference'))
533
381
 
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
382
 
543
383
class TestSmartServerRequestOpenBranchV2(TestCaseWithChrootedTransport):
544
384
 
546
386
        """When there is no branch, ('nobranch', ) is returned."""
547
387
        backing = self.get_transport()
548
388
        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(''))
 
389
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
390
        self.assertEqual(SmartServerResponse(('nobranch', )),
 
391
            request.execute(''))
 
392
 
 
393
    def test_branch(self):
 
394
        """When there is a branch, 'ok' is returned."""
 
395
        backing = self.get_transport()
 
396
        expected = self.make_branch('.')._format.network_name()
 
397
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
398
        self.assertEqual(SuccessfulSmartServerResponse(('branch', expected)),
 
399
            request.execute(''))
 
400
 
 
401
    def test_branch_reference(self):
 
402
        """When there is a branch reference, the reference URL is returned."""
 
403
        backing = self.get_transport()
 
404
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
405
        branch = self.make_branch('branch')
 
406
        checkout = branch.create_checkout('reference',lightweight=True)
 
407
        reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
 
408
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
 
409
        self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
 
410
            request.execute('reference'))
 
411
 
 
412
    def test_stacked_branch(self):
 
413
        """Opening a stacked branch does not open the stacked-on branch."""
 
414
        trunk = self.make_branch('trunk')
 
415
        feature = self.make_branch('feature', format='1.9')
 
416
        feature.set_stacked_on_url(trunk.base)
 
417
        opened_branches = []
 
418
        Branch.hooks.install_named_hook('open', opened_branches.append, None)
 
419
        backing = self.get_transport()
 
420
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
421
        request.setup_jail()
 
422
        try:
 
423
            response = request.execute('feature')
 
424
        finally:
 
425
            request.teardown_jail()
 
426
        expected_format = feature._format.network_name()
 
427
        self.assertEqual(
 
428
            SuccessfulSmartServerResponse(('branch', expected_format)),
 
429
            response)
 
430
        self.assertLength(1, opened_branches)
668
431
 
669
432
 
670
433
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
672
435
    def test_empty(self):
673
436
        """For an empty branch, the body is empty."""
674
437
        backing = self.get_transport()
675
 
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
 
438
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
676
439
        self.make_branch('.')
677
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), ''),
 
440
        self.assertEqual(SmartServerResponse(('ok', ), ''),
678
441
            request.execute(''))
679
442
 
680
443
    def test_not_empty(self):
681
444
        """For a non-empty branch, the body is empty."""
682
445
        backing = self.get_transport()
683
 
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
 
446
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
684
447
        tree = self.make_branch_and_memory_tree('.')
685
448
        tree.lock_write()
686
449
        tree.add('')
688
451
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
689
452
        tree.unlock()
690
453
        self.assertEqual(
691
 
            smart_req.SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
 
454
            SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
692
455
            request.execute(''))
693
456
 
694
457
 
697
460
    def test_no_branch(self):
698
461
        """When there is a bzrdir and no branch, NotBranchError is raised."""
699
462
        backing = self.get_transport()
700
 
        request = smart_branch.SmartServerBranchRequest(backing)
 
463
        request = smart.branch.SmartServerBranchRequest(backing)
701
464
        self.make_bzrdir('.')
702
465
        self.assertRaises(errors.NotBranchError,
703
466
            request.execute, '')
705
468
    def test_branch_reference(self):
706
469
        """When there is a branch reference, NotBranchError is raised."""
707
470
        backing = self.get_transport()
708
 
        request = smart_branch.SmartServerBranchRequest(backing)
 
471
        request = smart.branch.SmartServerBranchRequest(backing)
709
472
        branch = self.make_branch('branch')
710
473
        checkout = branch.create_checkout('reference',lightweight=True)
711
474
        self.assertRaises(errors.NotBranchError,
712
475
            request.execute, 'checkout')
713
476
 
714
477
 
715
 
class TestSmartServerBranchRequestLastRevisionInfo(
716
 
    tests.TestCaseWithMemoryTransport):
 
478
class TestSmartServerBranchRequestLastRevisionInfo(tests.TestCaseWithMemoryTransport):
717
479
 
718
480
    def test_empty(self):
719
481
        """For an empty branch, the result is ('ok', '0', 'null:')."""
720
482
        backing = self.get_transport()
721
 
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
483
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
722
484
        self.make_branch('.')
723
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', '0', 'null:')),
 
485
        self.assertEqual(SmartServerResponse(('ok', '0', 'null:')),
724
486
            request.execute(''))
725
487
 
726
488
    def test_not_empty(self):
727
489
        """For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
728
490
        backing = self.get_transport()
729
 
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
491
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
730
492
        tree = self.make_branch_and_memory_tree('.')
731
493
        tree.lock_write()
732
494
        tree.add('')
735
497
        r2 = tree.commit('2nd commit', rev_id=rev_id_utf8)
736
498
        tree.unlock()
737
499
        self.assertEqual(
738
 
            smart_req.SmartServerResponse(('ok', '2', rev_id_utf8)),
 
500
            SmartServerResponse(('ok', '2', rev_id_utf8)),
739
501
            request.execute(''))
740
502
 
741
503
 
742
 
class TestSmartServerBranchRequestGetConfigFile(
743
 
    tests.TestCaseWithMemoryTransport):
 
504
class TestSmartServerBranchRequestGetConfigFile(tests.TestCaseWithMemoryTransport):
744
505
 
745
506
    def test_default(self):
746
507
        """With no file, we get empty content."""
747
508
        backing = self.get_transport()
748
 
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
 
509
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
749
510
        branch = self.make_branch('.')
750
511
        # there should be no file by default
751
512
        content = ''
752
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), content),
 
513
        self.assertEqual(SmartServerResponse(('ok', ), content),
753
514
            request.execute(''))
754
515
 
755
516
    def test_with_content(self):
757
518
        # branch.control_files.get('branch.conf') for now - in the future it may
758
519
        # perform more complex processing.
759
520
        backing = self.get_transport()
760
 
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
 
521
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
761
522
        branch = self.make_branch('.')
762
523
        branch._transport.put_bytes('branch.conf', 'foo bar baz')
763
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'foo bar baz'),
 
524
        self.assertEqual(SmartServerResponse(('ok', ), 'foo bar baz'),
764
525
            request.execute(''))
765
526
 
766
527
 
767
528
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
768
529
 
769
530
    def get_lock_tokens(self, branch):
770
 
        branch_token = branch.lock_write().branch_token
771
 
        repo_token = branch.repository.lock_write().repository_token
 
531
        branch_token = branch.lock_write()
 
532
        repo_token = branch.repository.lock_write()
772
533
        branch.repository.unlock()
773
534
        return branch_token, repo_token
774
535
 
777
538
 
778
539
    def test_value_name(self):
779
540
        branch = self.make_branch('.')
780
 
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
 
541
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
781
542
            branch.bzrdir.root_transport)
782
543
        branch_token, repo_token = self.get_lock_tokens(branch)
783
544
        config = branch._get_config()
784
545
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
785
546
            '')
786
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
547
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
787
548
        self.assertEqual('bar', config.get_option('foo'))
788
 
        # Cleanup
789
 
        branch.unlock()
790
549
 
791
550
    def test_value_name_section(self):
792
551
        branch = self.make_branch('.')
793
 
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
 
552
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
794
553
            branch.bzrdir.root_transport)
795
554
        branch_token, repo_token = self.get_lock_tokens(branch)
796
555
        config = branch._get_config()
797
556
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
798
557
            'gam')
799
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
558
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
800
559
        self.assertEqual('bar', config.get_option('foo', 'gam'))
801
 
        # Cleanup
802
 
        branch.unlock()
803
 
 
804
 
 
805
 
class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):
806
 
    # Only called when the branch format and tags match [yay factory
807
 
    # methods] so only need to test straight forward cases.
808
 
 
809
 
    def test_set_bytes(self):
810
 
        base_branch = self.make_branch('base')
811
 
        tag_bytes = base_branch._get_tags_bytes()
812
 
        # get_lock_tokens takes out a lock.
813
 
        branch_token, repo_token = self.get_lock_tokens(base_branch)
814
 
        request = smart_branch.SmartServerBranchSetTagsBytes(
815
 
            self.get_transport())
816
 
        response = request.execute('base', branch_token, repo_token)
817
 
        self.assertEqual(None, response)
818
 
        response = request.do_chunk(tag_bytes)
819
 
        self.assertEqual(None, response)
820
 
        response = request.do_end()
821
 
        self.assertEquals(
822
 
            smart_req.SuccessfulSmartServerResponse(()), response)
823
 
        base_branch.unlock()
824
 
 
825
 
    def test_lock_failed(self):
826
 
        base_branch = self.make_branch('base')
827
 
        base_branch.lock_write()
828
 
        tag_bytes = base_branch._get_tags_bytes()
829
 
        request = smart_branch.SmartServerBranchSetTagsBytes(
830
 
            self.get_transport())
831
 
        self.assertRaises(errors.TokenMismatch, request.execute,
832
 
            'base', 'wrong token', 'wrong token')
833
 
        # The request handler will keep processing the message parts, so even
834
 
        # if the request fails immediately do_chunk and do_end are still
835
 
        # called.
836
 
        request.do_chunk(tag_bytes)
837
 
        request.do_end()
838
 
        base_branch.unlock()
839
 
 
840
560
 
841
561
 
842
562
class SetLastRevisionTestBase(TestLockedBranch):
863
583
 
864
584
    def assertRequestSucceeds(self, revision_id, revno):
865
585
        response = self.set_last_revision(revision_id, revno)
866
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
867
 
                         response)
 
586
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)), response)
868
587
 
869
588
 
870
589
class TestSetLastRevisionVerbMixin(object):
878
597
        """If the revision_id is not present, the verb returns NoSuchRevision.
879
598
        """
880
599
        revision_id = 'non-existent revision'
881
 
        self.assertEqual(smart_req.FailedSmartServerResponse(('NoSuchRevision',
882
 
                                                              revision_id)),
883
 
                         self.set_last_revision(revision_id, 1))
 
600
        self.assertEqual(
 
601
            FailedSmartServerResponse(('NoSuchRevision', revision_id)),
 
602
            self.set_last_revision(revision_id, 1))
884
603
 
885
604
    def make_tree_with_two_commits(self):
886
605
        self.tree.lock_write()
926
645
        rejection_message = u'rejection message\N{INTERROBANG}'
927
646
        def hook_that_rejects(params):
928
647
            raise errors.TipChangeRejected(rejection_message)
929
 
        _mod_branch.Branch.hooks.install_named_hook(
 
648
        Branch.hooks.install_named_hook(
930
649
            'pre_change_branch_tip', hook_that_rejects, None)
931
650
        self.assertEqual(
932
 
            smart_req.FailedSmartServerResponse(
 
651
            FailedSmartServerResponse(
933
652
                ('TipChangeRejected', rejection_message.encode('utf-8'))),
934
653
            self.set_last_revision('null:', 0))
935
654
 
938
657
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
939
658
    """Tests for Branch.set_last_revision verb."""
940
659
 
941
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevision
 
660
    request_class = smart.branch.SmartServerBranchRequestSetLastRevision
942
661
 
943
662
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
944
663
        return self.request.execute(
949
668
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
950
669
    """Tests for Branch.set_last_revision_info verb."""
951
670
 
952
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionInfo
 
671
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionInfo
953
672
 
954
673
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
955
674
        return self.request.execute(
966
685
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
967
686
    """Tests for Branch.set_last_revision_ex verb."""
968
687
 
969
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionEx
 
688
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionEx
970
689
 
971
690
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
972
691
        return self.request.execute(
975
694
    def assertRequestSucceeds(self, revision_id, revno):
976
695
        response = self.set_last_revision(revision_id, revno)
977
696
        self.assertEqual(
978
 
            smart_req.SuccessfulSmartServerResponse(('ok', revno, revision_id)),
 
697
            SuccessfulSmartServerResponse(('ok', revno, revision_id)),
979
698
            response)
980
699
 
981
700
    def test_branch_last_revision_info_rewind(self):
992
711
        response = self.request.execute(
993
712
            '', branch_token, repo_token, rev_id_utf8, 0, 0)
994
713
        self.assertEqual(
995
 
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
 
714
            SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
996
715
            response)
997
716
        self.assertEqual(
998
717
            (2, 'rev-2'), self.tree.branch.last_revision_info())
1002
721
        response = self.request.execute(
1003
722
            '', branch_token, repo_token, rev_id_utf8, 0, 1)
1004
723
        self.assertEqual(
1005
 
            smart_req.SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
 
724
            SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
1006
725
            response)
1007
726
        self.unlock_branch()
1008
727
        self.assertEqual(
1033
752
        """
1034
753
        self.make_branch_with_divergent_history()
1035
754
        self.assertEqual(
1036
 
            smart_req.FailedSmartServerResponse(('Diverged',)),
 
755
            FailedSmartServerResponse(('Diverged',)),
1037
756
            self.set_last_revision('child-1', 2))
1038
757
        # The branch tip was not changed.
1039
758
        self.assertEqual('child-2', self.tree.branch.last_revision())
1047
766
        response = self.request.execute(
1048
767
            '', branch_token, repo_token, 'child-1', 1, 0)
1049
768
        self.assertEqual(
1050
 
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
 
769
            SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
1051
770
            response)
1052
771
        self.unlock_branch()
1053
772
        # The branch tip was changed.
1058
777
 
1059
778
    def test_get_parent_none(self):
1060
779
        base_branch = self.make_branch('base')
1061
 
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
 
780
        request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1062
781
        response = request.execute('base')
1063
782
        self.assertEquals(
1064
 
            smart_req.SuccessfulSmartServerResponse(('',)), response)
 
783
            SuccessfulSmartServerResponse(('',)), response)
1065
784
 
1066
785
    def test_get_parent_something(self):
1067
786
        base_branch = self.make_branch('base')
1068
787
        base_branch.set_parent(self.get_url('foo'))
1069
 
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
 
788
        request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1070
789
        response = request.execute('base')
1071
790
        self.assertEquals(
1072
 
            smart_req.SuccessfulSmartServerResponse(("../foo",)),
 
791
            SuccessfulSmartServerResponse(("../foo",)),
1073
792
            response)
1074
793
 
1075
794
 
1076
 
class TestSmartServerBranchRequestSetParent(TestLockedBranch):
 
795
class TestSmartServerBranchRequestSetParent(tests.TestCaseWithMemoryTransport):
1077
796
 
1078
797
    def test_set_parent_none(self):
1079
798
        branch = self.make_branch('base', format="1.9")
1080
799
        branch.lock_write()
1081
800
        branch._set_parent_location('foo')
1082
801
        branch.unlock()
1083
 
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
 
802
        request = smart.branch.SmartServerBranchRequestSetParentLocation(
1084
803
            self.get_transport())
1085
 
        branch_token, repo_token = self.get_lock_tokens(branch)
 
804
        branch_token = branch.lock_write()
 
805
        repo_token = branch.repository.lock_write()
1086
806
        try:
1087
807
            response = request.execute('base', branch_token, repo_token, '')
1088
808
        finally:
 
809
            branch.repository.unlock()
1089
810
            branch.unlock()
1090
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
 
811
        self.assertEqual(SuccessfulSmartServerResponse(()), response)
1091
812
        self.assertEqual(None, branch.get_parent())
1092
813
 
1093
814
    def test_set_parent_something(self):
1094
815
        branch = self.make_branch('base', format="1.9")
1095
 
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
 
816
        request = smart.branch.SmartServerBranchRequestSetParentLocation(
1096
817
            self.get_transport())
1097
 
        branch_token, repo_token = self.get_lock_tokens(branch)
 
818
        branch_token = branch.lock_write()
 
819
        repo_token = branch.repository.lock_write()
1098
820
        try:
1099
821
            response = request.execute('base', branch_token, repo_token,
1100
822
            'http://bar/')
1101
823
        finally:
 
824
            branch.repository.unlock()
1102
825
            branch.unlock()
1103
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
 
826
        self.assertEqual(SuccessfulSmartServerResponse(()), response)
1104
827
        self.assertEqual('http://bar/', branch.get_parent())
1105
828
 
1106
829
 
1107
 
class TestSmartServerBranchRequestGetTagsBytes(
1108
 
    tests.TestCaseWithMemoryTransport):
1109
 
    # Only called when the branch format and tags match [yay factory
1110
 
    # methods] so only need to test straight forward cases.
 
830
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
 
831
# Only called when the branch format and tags match [yay factory
 
832
# methods] so only need to test straight forward cases.
1111
833
 
1112
834
    def test_get_bytes(self):
1113
835
        base_branch = self.make_branch('base')
1114
 
        request = smart_branch.SmartServerBranchGetTagsBytes(
 
836
        request = smart.branch.SmartServerBranchGetTagsBytes(
1115
837
            self.get_transport())
1116
838
        response = request.execute('base')
1117
839
        self.assertEquals(
1118
 
            smart_req.SuccessfulSmartServerResponse(('',)), response)
 
840
            SuccessfulSmartServerResponse(('',)), response)
1119
841
 
1120
842
 
1121
843
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
1125
847
        stacked_branch = self.make_branch('stacked', format='1.6')
1126
848
        # typically should be relative
1127
849
        stacked_branch.set_stacked_on_url('../base')
1128
 
        request = smart_branch.SmartServerBranchRequestGetStackedOnURL(
 
850
        request = smart.branch.SmartServerBranchRequestGetStackedOnURL(
1129
851
            self.get_transport())
1130
852
        response = request.execute('stacked')
1131
853
        self.assertEquals(
1132
 
            smart_req.SmartServerResponse(('ok', '../base')),
 
854
            SmartServerResponse(('ok', '../base')),
1133
855
            response)
1134
856
 
1135
857
 
1136
 
class TestSmartServerBranchRequestLockWrite(TestLockedBranch):
 
858
class TestSmartServerBranchRequestLockWrite(tests.TestCaseWithMemoryTransport):
1137
859
 
1138
860
    def setUp(self):
1139
861
        tests.TestCaseWithMemoryTransport.setUp(self)
1140
862
 
1141
863
    def test_lock_write_on_unlocked_branch(self):
1142
864
        backing = self.get_transport()
1143
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
865
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1144
866
        branch = self.make_branch('.', format='knit')
1145
867
        repository = branch.repository
1146
868
        response = request.execute('')
1147
869
        branch_nonce = branch.control_files._lock.peek().get('nonce')
1148
870
        repository_nonce = repository.control_files._lock.peek().get('nonce')
1149
 
        self.assertEqual(smart_req.SmartServerResponse(
1150
 
                ('ok', branch_nonce, repository_nonce)),
1151
 
                         response)
 
871
        self.assertEqual(
 
872
            SmartServerResponse(('ok', branch_nonce, repository_nonce)),
 
873
            response)
1152
874
        # The branch (and associated repository) is now locked.  Verify that
1153
875
        # with a new branch object.
1154
876
        new_branch = repository.bzrdir.open_branch()
1155
877
        self.assertRaises(errors.LockContention, new_branch.lock_write)
1156
 
        # Cleanup
1157
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
1158
 
        response = request.execute('', branch_nonce, repository_nonce)
1159
878
 
1160
879
    def test_lock_write_on_locked_branch(self):
1161
880
        backing = self.get_transport()
1162
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
881
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1163
882
        branch = self.make_branch('.')
1164
 
        branch_token = branch.lock_write().branch_token
 
883
        branch.lock_write()
1165
884
        branch.leave_lock_in_place()
1166
885
        branch.unlock()
1167
886
        response = request.execute('')
1168
887
        self.assertEqual(
1169
 
            smart_req.SmartServerResponse(('LockContention',)), response)
1170
 
        # Cleanup
1171
 
        branch.lock_write(branch_token)
1172
 
        branch.dont_leave_lock_in_place()
1173
 
        branch.unlock()
 
888
            SmartServerResponse(('LockContention',)), response)
1174
889
 
1175
890
    def test_lock_write_with_tokens_on_locked_branch(self):
1176
891
        backing = self.get_transport()
1177
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
892
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1178
893
        branch = self.make_branch('.', format='knit')
1179
 
        branch_token, repo_token = self.get_lock_tokens(branch)
 
894
        branch_token = branch.lock_write()
 
895
        repo_token = branch.repository.lock_write()
 
896
        branch.repository.unlock()
1180
897
        branch.leave_lock_in_place()
1181
898
        branch.repository.leave_lock_in_place()
1182
899
        branch.unlock()
1183
900
        response = request.execute('',
1184
901
                                   branch_token, repo_token)
1185
902
        self.assertEqual(
1186
 
            smart_req.SmartServerResponse(('ok', branch_token, repo_token)),
1187
 
            response)
1188
 
        # Cleanup
1189
 
        branch.repository.lock_write(repo_token)
1190
 
        branch.repository.dont_leave_lock_in_place()
1191
 
        branch.repository.unlock()
1192
 
        branch.lock_write(branch_token)
1193
 
        branch.dont_leave_lock_in_place()
1194
 
        branch.unlock()
 
903
            SmartServerResponse(('ok', branch_token, repo_token)), response)
1195
904
 
1196
905
    def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
1197
906
        backing = self.get_transport()
1198
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
907
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1199
908
        branch = self.make_branch('.', format='knit')
1200
 
        branch_token, repo_token = self.get_lock_tokens(branch)
 
909
        branch_token = branch.lock_write()
 
910
        repo_token = branch.repository.lock_write()
 
911
        branch.repository.unlock()
1201
912
        branch.leave_lock_in_place()
1202
913
        branch.repository.leave_lock_in_place()
1203
914
        branch.unlock()
1204
915
        response = request.execute('',
1205
916
                                   branch_token+'xxx', repo_token)
1206
917
        self.assertEqual(
1207
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
1208
 
        # Cleanup
1209
 
        branch.repository.lock_write(repo_token)
1210
 
        branch.repository.dont_leave_lock_in_place()
1211
 
        branch.repository.unlock()
1212
 
        branch.lock_write(branch_token)
1213
 
        branch.dont_leave_lock_in_place()
1214
 
        branch.unlock()
 
918
            SmartServerResponse(('TokenMismatch',)), response)
1215
919
 
1216
920
    def test_lock_write_on_locked_repo(self):
1217
921
        backing = self.get_transport()
1218
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
922
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1219
923
        branch = self.make_branch('.', format='knit')
1220
 
        repo = branch.repository
1221
 
        repo_token = repo.lock_write().repository_token
1222
 
        repo.leave_lock_in_place()
1223
 
        repo.unlock()
 
924
        branch.repository.lock_write()
 
925
        branch.repository.leave_lock_in_place()
 
926
        branch.repository.unlock()
1224
927
        response = request.execute('')
1225
928
        self.assertEqual(
1226
 
            smart_req.SmartServerResponse(('LockContention',)), response)
1227
 
        # Cleanup
1228
 
        repo.lock_write(repo_token)
1229
 
        repo.dont_leave_lock_in_place()
1230
 
        repo.unlock()
 
929
            SmartServerResponse(('LockContention',)), response)
1231
930
 
1232
931
    def test_lock_write_on_readonly_transport(self):
1233
932
        backing = self.get_readonly_transport()
1234
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
933
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1235
934
        branch = self.make_branch('.')
1236
935
        root = self.get_transport().clone('/')
1237
936
        path = urlutils.relative_url(root.base, self.get_transport().base)
1241
940
        self.assertEqual('LockFailed', error_name)
1242
941
 
1243
942
 
1244
 
class TestSmartServerBranchRequestUnlock(TestLockedBranch):
 
943
class TestSmartServerBranchRequestUnlock(tests.TestCaseWithMemoryTransport):
1245
944
 
1246
945
    def setUp(self):
1247
946
        tests.TestCaseWithMemoryTransport.setUp(self)
1248
947
 
1249
948
    def test_unlock_on_locked_branch_and_repo(self):
1250
949
        backing = self.get_transport()
1251
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
950
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1252
951
        branch = self.make_branch('.', format='knit')
1253
952
        # Lock the branch
1254
 
        branch_token, repo_token = self.get_lock_tokens(branch)
 
953
        branch_token = branch.lock_write()
 
954
        repo_token = branch.repository.lock_write()
 
955
        branch.repository.unlock()
1255
956
        # Unlock the branch (and repo) object, leaving the physical locks
1256
957
        # in place.
1257
958
        branch.leave_lock_in_place()
1260
961
        response = request.execute('',
1261
962
                                   branch_token, repo_token)
1262
963
        self.assertEqual(
1263
 
            smart_req.SmartServerResponse(('ok',)), response)
 
964
            SmartServerResponse(('ok',)), response)
1264
965
        # The branch is now unlocked.  Verify that with a new branch
1265
966
        # object.
1266
967
        new_branch = branch.bzrdir.open_branch()
1269
970
 
1270
971
    def test_unlock_on_unlocked_branch_unlocked_repo(self):
1271
972
        backing = self.get_transport()
1272
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
973
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1273
974
        branch = self.make_branch('.', format='knit')
1274
975
        response = request.execute(
1275
976
            '', 'branch token', 'repo token')
1276
977
        self.assertEqual(
1277
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
978
            SmartServerResponse(('TokenMismatch',)), response)
1278
979
 
1279
980
    def test_unlock_on_unlocked_branch_locked_repo(self):
1280
981
        backing = self.get_transport()
1281
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
982
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1282
983
        branch = self.make_branch('.', format='knit')
1283
984
        # Lock the repository.
1284
 
        repo_token = branch.repository.lock_write().repository_token
 
985
        repo_token = branch.repository.lock_write()
1285
986
        branch.repository.leave_lock_in_place()
1286
987
        branch.repository.unlock()
1287
988
        # Issue branch lock_write request on the unlocked branch (with locked
1288
989
        # repo).
1289
 
        response = request.execute('', 'branch token', repo_token)
 
990
        response = request.execute(
 
991
            '', 'branch token', repo_token)
1290
992
        self.assertEqual(
1291
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
1292
 
        # Cleanup
1293
 
        branch.repository.lock_write(repo_token)
1294
 
        branch.repository.dont_leave_lock_in_place()
1295
 
        branch.repository.unlock()
 
993
            SmartServerResponse(('TokenMismatch',)), response)
1296
994
 
1297
995
 
1298
996
class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport):
1304
1002
        # its the exact path being looked at and the server is not
1305
1003
        # searching.
1306
1004
        backing = self.get_transport()
1307
 
        request = smart_repo.SmartServerRepositoryRequest(backing)
 
1005
        request = smart.repository.SmartServerRepositoryRequest(backing)
1308
1006
        self.make_repository('.', shared=True)
1309
1007
        self.make_bzrdir('subdir')
1310
1008
        self.assertRaises(errors.NoRepositoryPresent,
1316
1014
    def test_trivial_bzipped(self):
1317
1015
        # This tests that the wire encoding is actually bzipped
1318
1016
        backing = self.get_transport()
1319
 
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
 
1017
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1320
1018
        tree = self.make_branch_and_memory_tree('.')
1321
1019
 
1322
1020
        self.assertEqual(None,
1323
1021
            request.execute('', 'missing-id'))
1324
1022
        # Note that it returns a body that is bzipped.
1325
1023
        self.assertEqual(
1326
 
            smart_req.SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
 
1024
            SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1327
1025
            request.do_body('\n\n0\n'))
1328
1026
 
1329
1027
    def test_trivial_include_missing(self):
1330
1028
        backing = self.get_transport()
1331
 
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
 
1029
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1332
1030
        tree = self.make_branch_and_memory_tree('.')
1333
1031
 
1334
1032
        self.assertEqual(None,
1335
1033
            request.execute('', 'missing-id', 'include-missing:'))
1336
1034
        self.assertEqual(
1337
 
            smart_req.SuccessfulSmartServerResponse(('ok', ),
 
1035
            SuccessfulSmartServerResponse(('ok', ),
1338
1036
                bz2.compress('missing:missing-id')),
1339
1037
            request.do_body('\n\n0\n'))
1340
1038
 
1341
1039
 
1342
 
class TestSmartServerRepositoryGetRevisionGraph(
1343
 
    tests.TestCaseWithMemoryTransport):
 
1040
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
1344
1041
 
1345
1042
    def test_none_argument(self):
1346
1043
        backing = self.get_transport()
1347
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1044
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1348
1045
        tree = self.make_branch_and_memory_tree('.')
1349
1046
        tree.lock_write()
1350
1047
        tree.add('')
1359
1056
        response.body = '\n'.join(sorted(response.body.split('\n')))
1360
1057
 
1361
1058
        self.assertEqual(
1362
 
            smart_req.SmartServerResponse(('ok', ), '\n'.join(lines)), response)
 
1059
            SmartServerResponse(('ok', ), '\n'.join(lines)), response)
1363
1060
 
1364
1061
    def test_specific_revision_argument(self):
1365
1062
        backing = self.get_transport()
1366
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1063
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1367
1064
        tree = self.make_branch_and_memory_tree('.')
1368
1065
        tree.lock_write()
1369
1066
        tree.add('')
1372
1069
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1373
1070
        tree.unlock()
1374
1071
 
1375
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), rev_id_utf8),
 
1072
        self.assertEqual(SmartServerResponse(('ok', ), rev_id_utf8),
1376
1073
            request.execute('', rev_id_utf8))
1377
1074
 
1378
1075
    def test_no_such_revision(self):
1379
1076
        backing = self.get_transport()
1380
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1077
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1381
1078
        tree = self.make_branch_and_memory_tree('.')
1382
1079
        tree.lock_write()
1383
1080
        tree.add('')
1385
1082
        tree.unlock()
1386
1083
 
1387
1084
        # Note that it still returns body (of zero bytes).
1388
 
        self.assertEqual(smart_req.SmartServerResponse(
1389
 
                ('nosuchrevision', 'missingrevision', ), ''),
1390
 
                         request.execute('', 'missingrevision'))
1391
 
 
1392
 
 
1393
 
class TestSmartServerRepositoryGetRevIdForRevno(
1394
 
    tests.TestCaseWithMemoryTransport):
1395
 
 
1396
 
    def test_revno_found(self):
1397
 
        backing = self.get_transport()
1398
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1399
 
        tree = self.make_branch_and_memory_tree('.')
1400
 
        tree.lock_write()
1401
 
        tree.add('')
1402
 
        rev1_id_utf8 = u'\xc8'.encode('utf-8')
1403
 
        rev2_id_utf8 = u'\xc9'.encode('utf-8')
1404
 
        tree.commit('1st commit', rev_id=rev1_id_utf8)
1405
 
        tree.commit('2nd commit', rev_id=rev2_id_utf8)
1406
 
        tree.unlock()
1407
 
 
1408
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', rev1_id_utf8)),
1409
 
            request.execute('', 1, (2, rev2_id_utf8)))
1410
 
 
1411
 
    def test_known_revid_missing(self):
1412
 
        backing = self.get_transport()
1413
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1414
 
        repo = self.make_repository('.')
1415
 
        self.assertEqual(
1416
 
            smart_req.FailedSmartServerResponse(('nosuchrevision', 'ghost')),
1417
 
            request.execute('', 1, (2, 'ghost')))
1418
 
 
1419
 
    def test_history_incomplete(self):
1420
 
        backing = self.get_transport()
1421
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1422
 
        parent = self.make_branch_and_memory_tree('parent', format='1.9')
1423
 
        parent.lock_write()
1424
 
        parent.add([''], ['TREE_ROOT'])
1425
 
        r1 = parent.commit(message='first commit')
1426
 
        r2 = parent.commit(message='second commit')
1427
 
        parent.unlock()
1428
 
        local = self.make_branch_and_memory_tree('local', format='1.9')
1429
 
        local.branch.pull(parent.branch)
1430
 
        local.set_parent_ids([r2])
1431
 
        r3 = local.commit(message='local commit')
1432
 
        local.branch.create_clone_on_transport(
1433
 
            self.get_transport('stacked'), stacked_on=self.get_url('parent'))
1434
 
        self.assertEqual(
1435
 
            smart_req.SmartServerResponse(('history-incomplete', 2, r2)),
1436
 
            request.execute('stacked', 1, (3, r3)))
 
1085
        self.assertEqual(
 
1086
            SmartServerResponse(('nosuchrevision', 'missingrevision', ), ''),
 
1087
            request.execute('', 'missingrevision'))
1437
1088
 
1438
1089
 
1439
1090
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1451
1102
    def test_ancestry_of(self):
1452
1103
        """The search argument may be a 'ancestry-of' some heads'."""
1453
1104
        backing = self.get_transport()
1454
 
        request = smart_repo.SmartServerRepositoryGetStream(backing)
 
1105
        request = smart.repository.SmartServerRepositoryGetStream(backing)
1455
1106
        repo, r1, r2 = self.make_two_commit_repo()
1456
1107
        fetch_spec = ['ancestry-of', r2]
1457
1108
        lines = '\n'.join(fetch_spec)
1464
1115
    def test_search(self):
1465
1116
        """The search argument may be a 'search' of some explicit keys."""
1466
1117
        backing = self.get_transport()
1467
 
        request = smart_repo.SmartServerRepositoryGetStream(backing)
 
1118
        request = smart.repository.SmartServerRepositoryGetStream(backing)
1468
1119
        repo, r1, r2 = self.make_two_commit_repo()
1469
1120
        fetch_spec = ['search', '%s %s' % (r1, r2), 'null:', '2']
1470
1121
        lines = '\n'.join(fetch_spec)
1480
1131
    def test_missing_revision(self):
1481
1132
        """For a missing revision, ('no', ) is returned."""
1482
1133
        backing = self.get_transport()
1483
 
        request = smart_repo.SmartServerRequestHasRevision(backing)
 
1134
        request = smart.repository.SmartServerRequestHasRevision(backing)
1484
1135
        self.make_repository('.')
1485
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1136
        self.assertEqual(SmartServerResponse(('no', )),
1486
1137
            request.execute('', 'revid'))
1487
1138
 
1488
1139
    def test_present_revision(self):
1489
1140
        """For a present revision, ('yes', ) is returned."""
1490
1141
        backing = self.get_transport()
1491
 
        request = smart_repo.SmartServerRequestHasRevision(backing)
 
1142
        request = smart.repository.SmartServerRequestHasRevision(backing)
1492
1143
        tree = self.make_branch_and_memory_tree('.')
1493
1144
        tree.lock_write()
1494
1145
        tree.add('')
1496
1147
        r1 = tree.commit('a commit', rev_id=rev_id_utf8)
1497
1148
        tree.unlock()
1498
1149
        self.assertTrue(tree.branch.repository.has_revision(rev_id_utf8))
1499
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1150
        self.assertEqual(SmartServerResponse(('yes', )),
1500
1151
            request.execute('', rev_id_utf8))
1501
1152
 
1502
1153
 
1505
1156
    def test_empty_revid(self):
1506
1157
        """With an empty revid, we get only size an number and revisions"""
1507
1158
        backing = self.get_transport()
1508
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1159
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1509
1160
        repository = self.make_repository('.')
1510
1161
        stats = repository.gather_stats()
1511
1162
        expected_body = 'revisions: 0\n'
1512
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1163
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1513
1164
                         request.execute('', '', 'no'))
1514
1165
 
1515
1166
    def test_revid_with_committers(self):
1516
1167
        """For a revid we get more infos."""
1517
1168
        backing = self.get_transport()
1518
1169
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1519
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1170
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1520
1171
        tree = self.make_branch_and_memory_tree('.')
1521
1172
        tree.lock_write()
1522
1173
        tree.add('')
1530
1181
        expected_body = ('firstrev: 123456.200 3600\n'
1531
1182
                         'latestrev: 654321.400 0\n'
1532
1183
                         'revisions: 2\n')
1533
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1184
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1534
1185
                         request.execute('',
1535
1186
                                         rev_id_utf8, 'no'))
1536
1187
 
1538
1189
        """For a revid and requesting committers we get the whole thing."""
1539
1190
        backing = self.get_transport()
1540
1191
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1541
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1192
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1542
1193
        tree = self.make_branch_and_memory_tree('.')
1543
1194
        tree.lock_write()
1544
1195
        tree.add('')
1554
1205
                         'firstrev: 123456.200 3600\n'
1555
1206
                         'latestrev: 654321.400 0\n'
1556
1207
                         'revisions: 2\n')
1557
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1208
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1558
1209
                         request.execute('',
1559
1210
                                         rev_id_utf8, 'yes'))
1560
1211
 
1564
1215
    def test_is_shared(self):
1565
1216
        """For a shared repository, ('yes', ) is returned."""
1566
1217
        backing = self.get_transport()
1567
 
        request = smart_repo.SmartServerRepositoryIsShared(backing)
 
1218
        request = smart.repository.SmartServerRepositoryIsShared(backing)
1568
1219
        self.make_repository('.', shared=True)
1569
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1220
        self.assertEqual(SmartServerResponse(('yes', )),
1570
1221
            request.execute('', ))
1571
1222
 
1572
1223
    def test_is_not_shared(self):
1573
1224
        """For a shared repository, ('no', ) is returned."""
1574
1225
        backing = self.get_transport()
1575
 
        request = smart_repo.SmartServerRepositoryIsShared(backing)
 
1226
        request = smart.repository.SmartServerRepositoryIsShared(backing)
1576
1227
        self.make_repository('.', shared=False)
1577
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1228
        self.assertEqual(SmartServerResponse(('no', )),
1578
1229
            request.execute('', ))
1579
1230
 
1580
1231
 
1582
1233
 
1583
1234
    def test_lock_write_on_unlocked_repo(self):
1584
1235
        backing = self.get_transport()
1585
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1236
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1586
1237
        repository = self.make_repository('.', format='knit')
1587
1238
        response = request.execute('')
1588
1239
        nonce = repository.control_files._lock.peek().get('nonce')
1589
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
 
1240
        self.assertEqual(SmartServerResponse(('ok', nonce)), response)
1590
1241
        # The repository is now locked.  Verify that with a new repository
1591
1242
        # object.
1592
1243
        new_repo = repository.bzrdir.open_repository()
1593
1244
        self.assertRaises(errors.LockContention, new_repo.lock_write)
1594
 
        # Cleanup
1595
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
1596
 
        response = request.execute('', nonce)
1597
1245
 
1598
1246
    def test_lock_write_on_locked_repo(self):
1599
1247
        backing = self.get_transport()
1600
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1248
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1601
1249
        repository = self.make_repository('.', format='knit')
1602
 
        repo_token = repository.lock_write().repository_token
 
1250
        repository.lock_write()
1603
1251
        repository.leave_lock_in_place()
1604
1252
        repository.unlock()
1605
1253
        response = request.execute('')
1606
1254
        self.assertEqual(
1607
 
            smart_req.SmartServerResponse(('LockContention',)), response)
1608
 
        # Cleanup
1609
 
        repository.lock_write(repo_token)
1610
 
        repository.dont_leave_lock_in_place()
1611
 
        repository.unlock()
 
1255
            SmartServerResponse(('LockContention',)), response)
1612
1256
 
1613
1257
    def test_lock_write_on_readonly_transport(self):
1614
1258
        backing = self.get_readonly_transport()
1615
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1259
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1616
1260
        repository = self.make_repository('.', format='knit')
1617
1261
        response = request.execute('')
1618
1262
        self.assertFalse(response.is_successful())
1622
1266
class TestInsertStreamBase(tests.TestCaseWithMemoryTransport):
1623
1267
 
1624
1268
    def make_empty_byte_stream(self, repo):
1625
 
        byte_stream = smart_repo._stream_to_byte_stream([], repo._format)
 
1269
        byte_stream = smart.repository._stream_to_byte_stream([], repo._format)
1626
1270
        return ''.join(byte_stream)
1627
1271
 
1628
1272
 
1630
1274
 
1631
1275
    def test_insert_stream_empty(self):
1632
1276
        backing = self.get_transport()
1633
 
        request = smart_repo.SmartServerRepositoryInsertStream(backing)
 
1277
        request = smart.repository.SmartServerRepositoryInsertStream(backing)
1634
1278
        repository = self.make_repository('.')
1635
1279
        response = request.execute('', '')
1636
1280
        self.assertEqual(None, response)
1637
1281
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1638
1282
        self.assertEqual(None, response)
1639
1283
        response = request.do_end()
1640
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1641
 
 
 
1284
        self.assertEqual(SmartServerResponse(('ok', )), response)
 
1285
        
1642
1286
 
1643
1287
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
1644
1288
 
1645
1289
    def test_insert_stream_empty(self):
1646
1290
        backing = self.get_transport()
1647
 
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
 
1291
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1648
1292
            backing)
1649
1293
        repository = self.make_repository('.', format='knit')
1650
 
        lock_token = repository.lock_write().repository_token
 
1294
        lock_token = repository.lock_write()
1651
1295
        response = request.execute('', '', lock_token)
1652
1296
        self.assertEqual(None, response)
1653
1297
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1654
1298
        self.assertEqual(None, response)
1655
1299
        response = request.do_end()
1656
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
 
1300
        self.assertEqual(SmartServerResponse(('ok', )), response)
1657
1301
        repository.unlock()
1658
1302
 
1659
1303
    def test_insert_stream_with_wrong_lock_token(self):
1660
1304
        backing = self.get_transport()
1661
 
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
 
1305
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1662
1306
            backing)
1663
1307
        repository = self.make_repository('.', format='knit')
1664
 
        lock_token = repository.lock_write().repository_token
 
1308
        lock_token = repository.lock_write()
1665
1309
        self.assertRaises(
1666
1310
            errors.TokenMismatch, request.execute, '', '', 'wrong-token')
1667
1311
        repository.unlock()
1674
1318
 
1675
1319
    def test_unlock_on_locked_repo(self):
1676
1320
        backing = self.get_transport()
1677
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1321
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1678
1322
        repository = self.make_repository('.', format='knit')
1679
 
        token = repository.lock_write().repository_token
 
1323
        token = repository.lock_write()
1680
1324
        repository.leave_lock_in_place()
1681
1325
        repository.unlock()
1682
1326
        response = request.execute('', token)
1683
1327
        self.assertEqual(
1684
 
            smart_req.SmartServerResponse(('ok',)), response)
 
1328
            SmartServerResponse(('ok',)), response)
1685
1329
        # The repository is now unlocked.  Verify that with a new repository
1686
1330
        # object.
1687
1331
        new_repo = repository.bzrdir.open_repository()
1690
1334
 
1691
1335
    def test_unlock_on_unlocked_repo(self):
1692
1336
        backing = self.get_transport()
1693
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1337
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1694
1338
        repository = self.make_repository('.', format='knit')
1695
1339
        response = request.execute('', 'some token')
1696
1340
        self.assertEqual(
1697
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1341
            SmartServerResponse(('TokenMismatch',)), response)
1698
1342
 
1699
1343
 
1700
1344
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1701
1345
 
1702
1346
    def test_is_readonly_no(self):
1703
1347
        backing = self.get_transport()
1704
 
        request = smart_req.SmartServerIsReadonly(backing)
 
1348
        request = smart.request.SmartServerIsReadonly(backing)
1705
1349
        response = request.execute()
1706
1350
        self.assertEqual(
1707
 
            smart_req.SmartServerResponse(('no',)), response)
 
1351
            SmartServerResponse(('no',)), response)
1708
1352
 
1709
1353
    def test_is_readonly_yes(self):
1710
1354
        backing = self.get_readonly_transport()
1711
 
        request = smart_req.SmartServerIsReadonly(backing)
 
1355
        request = smart.request.SmartServerIsReadonly(backing)
1712
1356
        response = request.execute()
1713
1357
        self.assertEqual(
1714
 
            smart_req.SmartServerResponse(('yes',)), response)
1715
 
 
1716
 
 
1717
 
class TestSmartServerRepositorySetMakeWorkingTrees(
1718
 
    tests.TestCaseWithMemoryTransport):
 
1358
            SmartServerResponse(('yes',)), response)
 
1359
 
 
1360
 
 
1361
class TestSmartServerRepositorySetMakeWorkingTrees(tests.TestCaseWithMemoryTransport):
1719
1362
 
1720
1363
    def test_set_false(self):
1721
1364
        backing = self.get_transport()
1722
1365
        repo = self.make_repository('.', shared=True)
1723
1366
        repo.set_make_working_trees(True)
1724
 
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
 
1367
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1725
1368
        request = request_class(backing)
1726
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1369
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1727
1370
            request.execute('', 'False'))
1728
1371
        repo = repo.bzrdir.open_repository()
1729
1372
        self.assertFalse(repo.make_working_trees())
1732
1375
        backing = self.get_transport()
1733
1376
        repo = self.make_repository('.', shared=True)
1734
1377
        repo.set_make_working_trees(False)
1735
 
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
 
1378
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1736
1379
        request = request_class(backing)
1737
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1380
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1738
1381
            request.execute('', 'True'))
1739
1382
        repo = repo.bzrdir.open_repository()
1740
1383
        self.assertTrue(repo.make_working_trees())
1759
1402
        repo.lock_write()
1760
1403
        self.addCleanup(repo.unlock)
1761
1404
        backing = self.get_transport()
1762
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1405
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1763
1406
            backing)
1764
1407
        response = request.execute('')
1765
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1408
        self.assertEqual(SmartServerResponse(('ok',)), response)
1766
1409
        repo._pack_collection.reload_pack_names()
1767
1410
        self.assertEqual(1, len(repo._pack_collection.names()))
1768
1411
 
1774
1417
        for x in range(9):
1775
1418
            tree.commit('commit %s' % x)
1776
1419
        backing = self.get_transport()
1777
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1420
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1778
1421
            backing)
1779
1422
        response = request.execute('')
1780
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1423
        self.assertEqual(SmartServerResponse(('ok',)), response)
1781
1424
        repo._pack_collection.reload_pack_names()
1782
1425
        self.assertEqual(9, len(repo._pack_collection.names()))
1783
1426
 
1785
1428
        """A request to autopack a non-pack repo is a no-op."""
1786
1429
        repo = self.make_repository('.', format='knit')
1787
1430
        backing = self.get_transport()
1788
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1431
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1789
1432
            backing)
1790
1433
        response = request.execute('')
1791
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
1792
 
 
1793
 
 
1794
 
class TestSmartServerVfsGet(tests.TestCaseWithMemoryTransport):
1795
 
 
1796
 
    def test_unicode_path(self):
1797
 
        """VFS requests expect unicode paths to be escaped."""
1798
 
        filename = u'foo\N{INTERROBANG}'
1799
 
        filename_escaped = urlutils.escape(filename)
1800
 
        backing = self.get_transport()
1801
 
        request = vfs.GetRequest(backing)
1802
 
        backing.put_bytes_non_atomic(filename_escaped, 'contents')
1803
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'contents'),
1804
 
            request.execute(filename_escaped))
 
1434
        self.assertEqual(SmartServerResponse(('ok',)), response)
1805
1435
 
1806
1436
 
1807
1437
class TestHandlers(tests.TestCase):
1811
1441
        """All registered request_handlers can be found."""
1812
1442
        # If there's a typo in a register_lazy call, this loop will fail with
1813
1443
        # an AttributeError.
1814
 
        for key, item in smart_req.request_handlers.iteritems():
 
1444
        for key, item in smart.request.request_handlers.iteritems():
1815
1445
            pass
1816
1446
 
1817
1447
    def assertHandlerEqual(self, verb, handler):
1818
 
        self.assertEqual(smart_req.request_handlers.get(verb), handler)
 
1448
        self.assertEqual(smart.request.request_handlers.get(verb), handler)
1819
1449
 
1820
1450
    def test_registered_methods(self):
1821
1451
        """Test that known methods are registered to the correct object."""
1822
1452
        self.assertHandlerEqual('Branch.get_config_file',
1823
 
            smart_branch.SmartServerBranchGetConfigFile)
 
1453
            smart.branch.SmartServerBranchGetConfigFile)
1824
1454
        self.assertHandlerEqual('Branch.get_parent',
1825
 
            smart_branch.SmartServerBranchGetParent)
 
1455
            smart.branch.SmartServerBranchGetParent)
1826
1456
        self.assertHandlerEqual('Branch.get_tags_bytes',
1827
 
            smart_branch.SmartServerBranchGetTagsBytes)
 
1457
            smart.branch.SmartServerBranchGetTagsBytes)
1828
1458
        self.assertHandlerEqual('Branch.lock_write',
1829
 
            smart_branch.SmartServerBranchRequestLockWrite)
 
1459
            smart.branch.SmartServerBranchRequestLockWrite)
1830
1460
        self.assertHandlerEqual('Branch.last_revision_info',
1831
 
            smart_branch.SmartServerBranchRequestLastRevisionInfo)
 
1461
            smart.branch.SmartServerBranchRequestLastRevisionInfo)
1832
1462
        self.assertHandlerEqual('Branch.revision_history',
1833
 
            smart_branch.SmartServerRequestRevisionHistory)
 
1463
            smart.branch.SmartServerRequestRevisionHistory)
1834
1464
        self.assertHandlerEqual('Branch.set_config_option',
1835
 
            smart_branch.SmartServerBranchRequestSetConfigOption)
 
1465
            smart.branch.SmartServerBranchRequestSetConfigOption)
1836
1466
        self.assertHandlerEqual('Branch.set_last_revision',
1837
 
            smart_branch.SmartServerBranchRequestSetLastRevision)
 
1467
            smart.branch.SmartServerBranchRequestSetLastRevision)
1838
1468
        self.assertHandlerEqual('Branch.set_last_revision_info',
1839
 
            smart_branch.SmartServerBranchRequestSetLastRevisionInfo)
 
1469
            smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
1840
1470
        self.assertHandlerEqual('Branch.set_last_revision_ex',
1841
 
            smart_branch.SmartServerBranchRequestSetLastRevisionEx)
 
1471
            smart.branch.SmartServerBranchRequestSetLastRevisionEx)
1842
1472
        self.assertHandlerEqual('Branch.set_parent_location',
1843
 
            smart_branch.SmartServerBranchRequestSetParentLocation)
 
1473
            smart.branch.SmartServerBranchRequestSetParentLocation)
1844
1474
        self.assertHandlerEqual('Branch.unlock',
1845
 
            smart_branch.SmartServerBranchRequestUnlock)
 
1475
            smart.branch.SmartServerBranchRequestUnlock)
1846
1476
        self.assertHandlerEqual('BzrDir.find_repository',
1847
 
            smart_dir.SmartServerRequestFindRepositoryV1)
 
1477
            smart.bzrdir.SmartServerRequestFindRepositoryV1)
1848
1478
        self.assertHandlerEqual('BzrDir.find_repositoryV2',
1849
 
            smart_dir.SmartServerRequestFindRepositoryV2)
 
1479
            smart.bzrdir.SmartServerRequestFindRepositoryV2)
1850
1480
        self.assertHandlerEqual('BzrDirFormat.initialize',
1851
 
            smart_dir.SmartServerRequestInitializeBzrDir)
1852
 
        self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
1853
 
            smart_dir.SmartServerRequestBzrDirInitializeEx)
 
1481
            smart.bzrdir.SmartServerRequestInitializeBzrDir)
1854
1482
        self.assertHandlerEqual('BzrDir.cloning_metadir',
1855
 
            smart_dir.SmartServerBzrDirRequestCloningMetaDir)
 
1483
            smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
1856
1484
        self.assertHandlerEqual('BzrDir.get_config_file',
1857
 
            smart_dir.SmartServerBzrDirRequestConfigFile)
 
1485
            smart.bzrdir.SmartServerBzrDirRequestConfigFile)
1858
1486
        self.assertHandlerEqual('BzrDir.open_branch',
1859
 
            smart_dir.SmartServerRequestOpenBranch)
 
1487
            smart.bzrdir.SmartServerRequestOpenBranch)
1860
1488
        self.assertHandlerEqual('BzrDir.open_branchV2',
1861
 
            smart_dir.SmartServerRequestOpenBranchV2)
1862
 
        self.assertHandlerEqual('BzrDir.open_branchV3',
1863
 
            smart_dir.SmartServerRequestOpenBranchV3)
 
1489
            smart.bzrdir.SmartServerRequestOpenBranchV2)
1864
1490
        self.assertHandlerEqual('PackRepository.autopack',
1865
 
            smart_packrepo.SmartServerPackRepositoryAutopack)
 
1491
            smart.packrepository.SmartServerPackRepositoryAutopack)
1866
1492
        self.assertHandlerEqual('Repository.gather_stats',
1867
 
            smart_repo.SmartServerRepositoryGatherStats)
 
1493
            smart.repository.SmartServerRepositoryGatherStats)
1868
1494
        self.assertHandlerEqual('Repository.get_parent_map',
1869
 
            smart_repo.SmartServerRepositoryGetParentMap)
1870
 
        self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1871
 
            smart_repo.SmartServerRepositoryGetRevIdForRevno)
 
1495
            smart.repository.SmartServerRepositoryGetParentMap)
1872
1496
        self.assertHandlerEqual('Repository.get_revision_graph',
1873
 
            smart_repo.SmartServerRepositoryGetRevisionGraph)
 
1497
            smart.repository.SmartServerRepositoryGetRevisionGraph)
1874
1498
        self.assertHandlerEqual('Repository.get_stream',
1875
 
            smart_repo.SmartServerRepositoryGetStream)
 
1499
            smart.repository.SmartServerRepositoryGetStream)
1876
1500
        self.assertHandlerEqual('Repository.has_revision',
1877
 
            smart_repo.SmartServerRequestHasRevision)
 
1501
            smart.repository.SmartServerRequestHasRevision)
1878
1502
        self.assertHandlerEqual('Repository.insert_stream',
1879
 
            smart_repo.SmartServerRepositoryInsertStream)
 
1503
            smart.repository.SmartServerRepositoryInsertStream)
1880
1504
        self.assertHandlerEqual('Repository.insert_stream_locked',
1881
 
            smart_repo.SmartServerRepositoryInsertStreamLocked)
 
1505
            smart.repository.SmartServerRepositoryInsertStreamLocked)
1882
1506
        self.assertHandlerEqual('Repository.is_shared',
1883
 
            smart_repo.SmartServerRepositoryIsShared)
 
1507
            smart.repository.SmartServerRepositoryIsShared)
1884
1508
        self.assertHandlerEqual('Repository.lock_write',
1885
 
            smart_repo.SmartServerRepositoryLockWrite)
 
1509
            smart.repository.SmartServerRepositoryLockWrite)
1886
1510
        self.assertHandlerEqual('Repository.tarball',
1887
 
            smart_repo.SmartServerRepositoryTarball)
 
1511
            smart.repository.SmartServerRepositoryTarball)
1888
1512
        self.assertHandlerEqual('Repository.unlock',
1889
 
            smart_repo.SmartServerRepositoryUnlock)
 
1513
            smart.repository.SmartServerRepositoryUnlock)
1890
1514
        self.assertHandlerEqual('Transport.is_readonly',
1891
 
            smart_req.SmartServerIsReadonly)
 
1515
            smart.request.SmartServerIsReadonly)