/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: Vincent Ladeuil
  • Date: 2009-08-26 09:06:02 UTC
  • mto: (4651.1.2 integration)
  • mto: This revision was merged to the branch mainline in revision 4653.
  • Revision ID: v.ladeuil+lp@free.fr-20090826090602-uu9vapyw6yhbz6ak
Catch up fix for #347649.

* bzrlib/tests/blackbox/test_filesystem_cicp.py:
(TestMisc.test_status): status display parents if modified

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