/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: 2009-10-15 21:28:14 UTC
  • mfrom: (4634.75.2 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20091015212814-i4j0hjrcob5cdw6j
(mbp) Fix bug #446033 by skipping non-existing entries in readdir.

Show diffs side-by-side

added added

removed removed

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