/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-01-20 16:47:49 UTC
  • mfrom: (4964.2.5 trivial)
  • Revision ID: pqm@pqm.ubuntu.com-20100120164749-d4mdz4g4jpl866mt
(mbp) Some reprs to help with debugging and interactive use

Show diffs side-by-side

added added

removed removed

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