← 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: Martin
  • Date: 2010-09-09 17:24:10 UTC
  • mto: (4797.58.10 2.1)
  • mto: This revision was merged to the branch mainline in revision 5431.
  • Revision ID: gzlist@googlemail.com-20100909172410-5pgfvsx8mst0d3af
https://launchpad.net/bugs/254278
Prevent AttributeError in xml_serializer on certain cElementTree setups

Show diffs side-by-side

added added

removed removed

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