← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

local_concurrency can be overridden from command-line

Show diffs side-by-side

added added

removed removed

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