← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: John Arbash Meinel
  • Date: 2009-09-22 02:18:24 UTC
  • mto: This revision was merged to the branch mainline in revision 4709.
  • Revision ID: john@arbash-meinel.com-20090922021824-j3en52uqoof7ym89
Remove some assert statements.

Show diffs side-by-side

added added

removed removed

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