← 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: Robert Collins
  • Date: 2009-12-16 22:29:31 UTC
  • mto: This revision was merged to the branch mainline in revision 4920.
  • Revision ID: robertc@robertcollins.net-20091216222931-wbbn5ey4mwmpatwd
Review feedback.

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, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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(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
 
    def test_notification_on_branch_from_repository(self):
531
 
        """When there is a repository, the error should return details."""
532
 
        backing = self.get_transport()
533
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
534
 
        repo = self.make_repository('.')
535
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
536
 
            request.execute(''))
537
 
 
538
527
 
539
528
class TestSmartServerRequestOpenBranchV2(TestCaseWithChrootedTransport):
540
529
 
542
531
        """When there is no branch, ('nobranch', ) is returned."""
543
532
        backing = self.get_transport()
544
533
        self.make_bzrdir('.')
545
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
546
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
547
 
            request.execute(''))
548
 
 
549
 
    def test_branch(self):
550
 
        """When there is a branch, 'ok' is returned."""
551
 
        backing = self.get_transport()
552
 
        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(''))
557
 
 
558
 
    def test_branch_reference(self):
559
 
        """When there is a branch reference, the reference URL is returned."""
560
 
        self.vfs_transport_factory = test_server.LocalURLServer
561
 
        backing = self.get_transport()
562
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
563
 
        branch = self.make_branch('branch')
564
 
        checkout = branch.create_checkout('reference',lightweight=True)
565
 
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
566
 
            checkout.bzrdir)
567
 
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
568
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
569
 
                ('ref', reference_url)),
570
 
                         request.execute('reference'))
571
 
 
572
 
    def test_stacked_branch(self):
573
 
        """Opening a stacked branch does not open the stacked-on branch."""
574
 
        trunk = self.make_branch('trunk')
575
 
        feature = self.make_branch('feature')
576
 
        feature.set_stacked_on_url(trunk.base)
577
 
        opened_branches = []
578
 
        _mod_branch.Branch.hooks.install_named_hook(
579
 
            'open', opened_branches.append, None)
580
 
        backing = self.get_transport()
581
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
582
 
        request.setup_jail()
583
 
        try:
584
 
            response = request.execute('feature')
585
 
        finally:
586
 
            request.teardown_jail()
587
 
        expected_format = feature._format.network_name()
588
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
589
 
                ('branch', expected_format)),
590
 
                         response)
591
 
        self.assertLength(1, opened_branches)
592
 
 
593
 
    def test_notification_on_branch_from_repository(self):
594
 
        """When there is a repository, the error should return details."""
595
 
        backing = self.get_transport()
596
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
597
 
        repo = self.make_repository('.')
598
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
599
 
            request.execute(''))
600
 
 
601
 
 
602
 
class TestSmartServerRequestOpenBranchV3(TestCaseWithChrootedTransport):
603
 
 
604
 
    def test_no_branch(self):
605
 
        """When there is no branch, ('nobranch', ) is returned."""
606
 
        backing = self.get_transport()
607
 
        self.make_bzrdir('.')
608
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
609
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
610
 
            request.execute(''))
611
 
 
612
 
    def test_branch(self):
613
 
        """When there is a branch, 'ok' is returned."""
614
 
        backing = self.get_transport()
615
 
        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(''))
620
 
 
621
 
    def test_branch_reference(self):
622
 
        """When there is a branch reference, the reference URL is returned."""
623
 
        self.vfs_transport_factory = test_server.LocalURLServer
624
 
        backing = self.get_transport()
625
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
626
 
        branch = self.make_branch('branch')
627
 
        checkout = branch.create_checkout('reference',lightweight=True)
628
 
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
629
 
            checkout.bzrdir)
630
 
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
631
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
632
 
                ('ref', reference_url)),
633
 
                         request.execute('reference'))
634
 
 
635
 
    def test_stacked_branch(self):
636
 
        """Opening a stacked branch does not open the stacked-on branch."""
637
 
        trunk = self.make_branch('trunk')
638
 
        feature = self.make_branch('feature')
639
 
        feature.set_stacked_on_url(trunk.base)
640
 
        opened_branches = []
641
 
        _mod_branch.Branch.hooks.install_named_hook(
642
 
            'open', opened_branches.append, None)
643
 
        backing = self.get_transport()
644
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
645
 
        request.setup_jail()
646
 
        try:
647
 
            response = request.execute('feature')
648
 
        finally:
649
 
            request.teardown_jail()
650
 
        expected_format = feature._format.network_name()
651
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
652
 
                ('branch', expected_format)),
653
 
                         response)
654
 
        self.assertLength(1, opened_branches)
655
 
 
656
 
    def test_notification_on_branch_from_repository(self):
657
 
        """When there is a repository, the error should return details."""
658
 
        backing = self.get_transport()
659
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
660
 
        repo = self.make_repository('.')
661
 
        self.assertEqual(smart_req.SmartServerResponse(
662
 
                ('nobranch', 'location is a repository')),
663
 
                         request.execute(''))
 
534
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
535
        self.assertEqual(SmartServerResponse(('nobranch', )),
 
536
            request.execute(''))
 
537
 
 
538
    def test_branch(self):
 
539
        """When there is a branch, 'ok' is returned."""
 
540
        backing = self.get_transport()
 
541
        expected = self.make_branch('.')._format.network_name()
 
542
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
543
        self.assertEqual(SuccessfulSmartServerResponse(('branch', expected)),
 
544
            request.execute(''))
 
545
 
 
546
    def test_branch_reference(self):
 
547
        """When there is a branch reference, the reference URL is returned."""
 
548
        self.vfs_transport_factory = local.LocalURLServer
 
549
        backing = self.get_transport()
 
550
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
551
        branch = self.make_branch('branch')
 
552
        checkout = branch.create_checkout('reference',lightweight=True)
 
553
        reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
 
554
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
 
555
        self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
 
556
            request.execute('reference'))
 
557
 
 
558
    def test_stacked_branch(self):
 
559
        """Opening a stacked branch does not open the stacked-on branch."""
 
560
        trunk = self.make_branch('trunk')
 
561
        feature = self.make_branch('feature')
 
562
        feature.set_stacked_on_url(trunk.base)
 
563
        opened_branches = []
 
564
        Branch.hooks.install_named_hook('open', opened_branches.append, None)
 
565
        backing = self.get_transport()
 
566
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
567
        request.setup_jail()
 
568
        try:
 
569
            response = request.execute('feature')
 
570
        finally:
 
571
            request.teardown_jail()
 
572
        expected_format = feature._format.network_name()
 
573
        self.assertEqual(
 
574
            SuccessfulSmartServerResponse(('branch', expected_format)),
 
575
            response)
 
576
        self.assertLength(1, opened_branches)
664
577
 
665
578
 
666
579
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
668
581
    def test_empty(self):
669
582
        """For an empty branch, the body is empty."""
670
583
        backing = self.get_transport()
671
 
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
 
584
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
672
585
        self.make_branch('.')
673
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), ''),
 
586
        self.assertEqual(SmartServerResponse(('ok', ), ''),
674
587
            request.execute(''))
675
588
 
676
589
    def test_not_empty(self):
677
590
        """For a non-empty branch, the body is empty."""
678
591
        backing = self.get_transport()
679
 
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
 
592
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
680
593
        tree = self.make_branch_and_memory_tree('.')
681
594
        tree.lock_write()
682
595
        tree.add('')
684
597
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
685
598
        tree.unlock()
686
599
        self.assertEqual(
687
 
            smart_req.SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
 
600
            SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
688
601
            request.execute(''))
689
602
 
690
603
 
693
606
    def test_no_branch(self):
694
607
        """When there is a bzrdir and no branch, NotBranchError is raised."""
695
608
        backing = self.get_transport()
696
 
        request = smart_branch.SmartServerBranchRequest(backing)
 
609
        request = smart.branch.SmartServerBranchRequest(backing)
697
610
        self.make_bzrdir('.')
698
611
        self.assertRaises(errors.NotBranchError,
699
612
            request.execute, '')
701
614
    def test_branch_reference(self):
702
615
        """When there is a branch reference, NotBranchError is raised."""
703
616
        backing = self.get_transport()
704
 
        request = smart_branch.SmartServerBranchRequest(backing)
 
617
        request = smart.branch.SmartServerBranchRequest(backing)
705
618
        branch = self.make_branch('branch')
706
619
        checkout = branch.create_checkout('reference',lightweight=True)
707
620
        self.assertRaises(errors.NotBranchError,
708
621
            request.execute, 'checkout')
709
622
 
710
623
 
711
 
class TestSmartServerBranchRequestLastRevisionInfo(
712
 
    tests.TestCaseWithMemoryTransport):
 
624
class TestSmartServerBranchRequestLastRevisionInfo(tests.TestCaseWithMemoryTransport):
713
625
 
714
626
    def test_empty(self):
715
627
        """For an empty branch, the result is ('ok', '0', 'null:')."""
716
628
        backing = self.get_transport()
717
 
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
629
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
718
630
        self.make_branch('.')
719
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', '0', 'null:')),
 
631
        self.assertEqual(SmartServerResponse(('ok', '0', 'null:')),
720
632
            request.execute(''))
721
633
 
722
634
    def test_not_empty(self):
723
635
        """For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
724
636
        backing = self.get_transport()
725
 
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
637
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
726
638
        tree = self.make_branch_and_memory_tree('.')
727
639
        tree.lock_write()
728
640
        tree.add('')
731
643
        r2 = tree.commit('2nd commit', rev_id=rev_id_utf8)
732
644
        tree.unlock()
733
645
        self.assertEqual(
734
 
            smart_req.SmartServerResponse(('ok', '2', rev_id_utf8)),
 
646
            SmartServerResponse(('ok', '2', rev_id_utf8)),
735
647
            request.execute(''))
736
648
 
737
649
 
738
 
class TestSmartServerBranchRequestGetConfigFile(
739
 
    tests.TestCaseWithMemoryTransport):
 
650
class TestSmartServerBranchRequestGetConfigFile(tests.TestCaseWithMemoryTransport):
740
651
 
741
652
    def test_default(self):
742
653
        """With no file, we get empty content."""
743
654
        backing = self.get_transport()
744
 
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
 
655
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
745
656
        branch = self.make_branch('.')
746
657
        # there should be no file by default
747
658
        content = ''
748
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), content),
 
659
        self.assertEqual(SmartServerResponse(('ok', ), content),
749
660
            request.execute(''))
750
661
 
751
662
    def test_with_content(self):
753
664
        # branch.control_files.get('branch.conf') for now - in the future it may
754
665
        # perform more complex processing.
755
666
        backing = self.get_transport()
756
 
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
 
667
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
757
668
        branch = self.make_branch('.')
758
669
        branch._transport.put_bytes('branch.conf', 'foo bar baz')
759
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'foo bar baz'),
 
670
        self.assertEqual(SmartServerResponse(('ok', ), 'foo bar baz'),
760
671
            request.execute(''))
761
672
 
762
673
 
763
674
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
764
675
 
765
676
    def get_lock_tokens(self, branch):
766
 
        branch_token = branch.lock_write().branch_token
767
 
        repo_token = branch.repository.lock_write().repository_token
 
677
        branch_token = branch.lock_write()
 
678
        repo_token = branch.repository.lock_write()
768
679
        branch.repository.unlock()
769
680
        return branch_token, repo_token
770
681
 
773
684
 
774
685
    def test_value_name(self):
775
686
        branch = self.make_branch('.')
776
 
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
 
687
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
777
688
            branch.bzrdir.root_transport)
778
689
        branch_token, repo_token = self.get_lock_tokens(branch)
779
690
        config = branch._get_config()
780
691
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
781
692
            '')
782
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
693
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
783
694
        self.assertEqual('bar', config.get_option('foo'))
784
695
        # Cleanup
785
696
        branch.unlock()
786
697
 
787
698
    def test_value_name_section(self):
788
699
        branch = self.make_branch('.')
789
 
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
 
700
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
790
701
            branch.bzrdir.root_transport)
791
702
        branch_token, repo_token = self.get_lock_tokens(branch)
792
703
        config = branch._get_config()
793
704
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
794
705
            'gam')
795
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
706
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
796
707
        self.assertEqual('bar', config.get_option('foo', 'gam'))
797
708
        # Cleanup
798
709
        branch.unlock()
799
710
 
800
711
 
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
712
class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):
840
713
    # Only called when the branch format and tags match [yay factory
841
714
    # methods] so only need to test straight forward cases.
845
718
        tag_bytes = base_branch._get_tags_bytes()
846
719
        # get_lock_tokens takes out a lock.
847
720
        branch_token, repo_token = self.get_lock_tokens(base_branch)
848
 
        request = smart_branch.SmartServerBranchSetTagsBytes(
 
721
        request = smart.branch.SmartServerBranchSetTagsBytes(
849
722
            self.get_transport())
850
723
        response = request.execute('base', branch_token, repo_token)
851
724
        self.assertEqual(None, response)
853
726
        self.assertEqual(None, response)
854
727
        response = request.do_end()
855
728
        self.assertEquals(
856
 
            smart_req.SuccessfulSmartServerResponse(()), response)
 
729
            SuccessfulSmartServerResponse(()), response)
857
730
        base_branch.unlock()
858
731
 
859
732
    def test_lock_failed(self):
860
733
        base_branch = self.make_branch('base')
861
734
        base_branch.lock_write()
862
735
        tag_bytes = base_branch._get_tags_bytes()
863
 
        request = smart_branch.SmartServerBranchSetTagsBytes(
 
736
        request = smart.branch.SmartServerBranchSetTagsBytes(
864
737
            self.get_transport())
865
738
        self.assertRaises(errors.TokenMismatch, request.execute,
866
739
            'base', 'wrong token', 'wrong token')
897
770
 
898
771
    def assertRequestSucceeds(self, revision_id, revno):
899
772
        response = self.set_last_revision(revision_id, revno)
900
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
901
 
                         response)
 
773
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)), response)
902
774
 
903
775
 
904
776
class TestSetLastRevisionVerbMixin(object):
912
784
        """If the revision_id is not present, the verb returns NoSuchRevision.
913
785
        """
914
786
        revision_id = 'non-existent revision'
915
 
        self.assertEqual(smart_req.FailedSmartServerResponse(('NoSuchRevision',
916
 
                                                              revision_id)),
917
 
                         self.set_last_revision(revision_id, 1))
 
787
        self.assertEqual(
 
788
            FailedSmartServerResponse(('NoSuchRevision', revision_id)),
 
789
            self.set_last_revision(revision_id, 1))
918
790
 
919
791
    def make_tree_with_two_commits(self):
920
792
        self.tree.lock_write()
932
804
        # its repository.
933
805
        self.make_tree_with_two_commits()
934
806
        rev_id_utf8 = u'\xc8'.encode('utf-8')
935
 
        self.tree.branch.set_last_revision_info(0, 'null:')
 
807
        self.tree.branch.set_revision_history([])
936
808
        self.assertEqual(
937
809
            (0, 'null:'), self.tree.branch.last_revision_info())
938
810
        # We can update the branch to a revision that is present in the
960
832
        rejection_message = u'rejection message\N{INTERROBANG}'
961
833
        def hook_that_rejects(params):
962
834
            raise errors.TipChangeRejected(rejection_message)
963
 
        _mod_branch.Branch.hooks.install_named_hook(
 
835
        Branch.hooks.install_named_hook(
964
836
            'pre_change_branch_tip', hook_that_rejects, None)
965
837
        self.assertEqual(
966
 
            smart_req.FailedSmartServerResponse(
 
838
            FailedSmartServerResponse(
967
839
                ('TipChangeRejected', rejection_message.encode('utf-8'))),
968
840
            self.set_last_revision('null:', 0))
969
841
 
972
844
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
973
845
    """Tests for Branch.set_last_revision verb."""
974
846
 
975
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevision
 
847
    request_class = smart.branch.SmartServerBranchRequestSetLastRevision
976
848
 
977
849
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
978
850
        return self.request.execute(
983
855
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
984
856
    """Tests for Branch.set_last_revision_info verb."""
985
857
 
986
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionInfo
 
858
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionInfo
987
859
 
988
860
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
989
861
        return self.request.execute(
1000
872
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
1001
873
    """Tests for Branch.set_last_revision_ex verb."""
1002
874
 
1003
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionEx
 
875
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionEx
1004
876
 
1005
877
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
1006
878
        return self.request.execute(
1009
881
    def assertRequestSucceeds(self, revision_id, revno):
1010
882
        response = self.set_last_revision(revision_id, revno)
1011
883
        self.assertEqual(
1012
 
            smart_req.SuccessfulSmartServerResponse(('ok', revno, revision_id)),
 
884
            SuccessfulSmartServerResponse(('ok', revno, revision_id)),
1013
885
            response)
1014
886
 
1015
887
    def test_branch_last_revision_info_rewind(self):
1026
898
        response = self.request.execute(
1027
899
            '', branch_token, repo_token, rev_id_utf8, 0, 0)
1028
900
        self.assertEqual(
1029
 
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
 
901
            SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
1030
902
            response)
1031
903
        self.assertEqual(
1032
904
            (2, 'rev-2'), self.tree.branch.last_revision_info())
1036
908
        response = self.request.execute(
1037
909
            '', branch_token, repo_token, rev_id_utf8, 0, 1)
1038
910
        self.assertEqual(
1039
 
            smart_req.SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
 
911
            SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
1040
912
            response)
1041
913
        self.unlock_branch()
1042
914
        self.assertEqual(
1067
939
        """
1068
940
        self.make_branch_with_divergent_history()
1069
941
        self.assertEqual(
1070
 
            smart_req.FailedSmartServerResponse(('Diverged',)),
 
942
            FailedSmartServerResponse(('Diverged',)),
1071
943
            self.set_last_revision('child-1', 2))
1072
944
        # The branch tip was not changed.
1073
945
        self.assertEqual('child-2', self.tree.branch.last_revision())
1081
953
        response = self.request.execute(
1082
954
            '', branch_token, repo_token, 'child-1', 1, 0)
1083
955
        self.assertEqual(
1084
 
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
 
956
            SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
1085
957
            response)
1086
958
        self.unlock_branch()
1087
959
        # The branch tip was changed.
1092
964
 
1093
965
    def test_get_parent_none(self):
1094
966
        base_branch = self.make_branch('base')
1095
 
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
 
967
        request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1096
968
        response = request.execute('base')
1097
969
        self.assertEquals(
1098
 
            smart_req.SuccessfulSmartServerResponse(('',)), response)
 
970
            SuccessfulSmartServerResponse(('',)), response)
1099
971
 
1100
972
    def test_get_parent_something(self):
1101
973
        base_branch = self.make_branch('base')
1102
974
        base_branch.set_parent(self.get_url('foo'))
1103
 
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
 
975
        request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1104
976
        response = request.execute('base')
1105
977
        self.assertEquals(
1106
 
            smart_req.SuccessfulSmartServerResponse(("../foo",)),
 
978
            SuccessfulSmartServerResponse(("../foo",)),
1107
979
            response)
1108
980
 
1109
981
 
1110
 
class TestSmartServerBranchRequestSetParent(TestLockedBranch):
 
982
class TestSmartServerBranchRequestSetParent(tests.TestCaseWithMemoryTransport):
1111
983
 
1112
984
    def test_set_parent_none(self):
1113
985
        branch = self.make_branch('base', format="1.9")
1114
986
        branch.lock_write()
1115
987
        branch._set_parent_location('foo')
1116
988
        branch.unlock()
1117
 
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
 
989
        request = smart.branch.SmartServerBranchRequestSetParentLocation(
1118
990
            self.get_transport())
1119
 
        branch_token, repo_token = self.get_lock_tokens(branch)
 
991
        branch_token = branch.lock_write()
 
992
        repo_token = branch.repository.lock_write()
1120
993
        try:
1121
994
            response = request.execute('base', branch_token, repo_token, '')
1122
995
        finally:
 
996
            branch.repository.unlock()
1123
997
            branch.unlock()
1124
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
 
998
        self.assertEqual(SuccessfulSmartServerResponse(()), response)
1125
999
        self.assertEqual(None, branch.get_parent())
1126
1000
 
1127
1001
    def test_set_parent_something(self):
1128
1002
        branch = self.make_branch('base', format="1.9")
1129
 
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
 
1003
        request = smart.branch.SmartServerBranchRequestSetParentLocation(
1130
1004
            self.get_transport())
1131
 
        branch_token, repo_token = self.get_lock_tokens(branch)
 
1005
        branch_token = branch.lock_write()
 
1006
        repo_token = branch.repository.lock_write()
1132
1007
        try:
1133
1008
            response = request.execute('base', branch_token, repo_token,
1134
1009
            'http://bar/')
1135
1010
        finally:
 
1011
            branch.repository.unlock()
1136
1012
            branch.unlock()
1137
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
 
1013
        self.assertEqual(SuccessfulSmartServerResponse(()), response)
1138
1014
        self.assertEqual('http://bar/', branch.get_parent())
1139
1015
 
1140
1016
 
1141
 
class TestSmartServerBranchRequestGetTagsBytes(
1142
 
    tests.TestCaseWithMemoryTransport):
 
1017
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
1143
1018
    # Only called when the branch format and tags match [yay factory
1144
1019
    # methods] so only need to test straight forward cases.
1145
1020
 
1146
1021
    def test_get_bytes(self):
1147
1022
        base_branch = self.make_branch('base')
1148
 
        request = smart_branch.SmartServerBranchGetTagsBytes(
 
1023
        request = smart.branch.SmartServerBranchGetTagsBytes(
1149
1024
            self.get_transport())
1150
1025
        response = request.execute('base')
1151
1026
        self.assertEquals(
1152
 
            smart_req.SuccessfulSmartServerResponse(('',)), response)
 
1027
            SuccessfulSmartServerResponse(('',)), response)
1153
1028
 
1154
1029
 
1155
1030
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
1159
1034
        stacked_branch = self.make_branch('stacked', format='1.6')
1160
1035
        # typically should be relative
1161
1036
        stacked_branch.set_stacked_on_url('../base')
1162
 
        request = smart_branch.SmartServerBranchRequestGetStackedOnURL(
 
1037
        request = smart.branch.SmartServerBranchRequestGetStackedOnURL(
1163
1038
            self.get_transport())
1164
1039
        response = request.execute('stacked')
1165
1040
        self.assertEquals(
1166
 
            smart_req.SmartServerResponse(('ok', '../base')),
 
1041
            SmartServerResponse(('ok', '../base')),
1167
1042
            response)
1168
1043
 
1169
1044
 
1170
 
class TestSmartServerBranchRequestLockWrite(TestLockedBranch):
 
1045
class TestSmartServerBranchRequestLockWrite(tests.TestCaseWithMemoryTransport):
1171
1046
 
1172
1047
    def setUp(self):
1173
1048
        tests.TestCaseWithMemoryTransport.setUp(self)
1174
1049
 
1175
1050
    def test_lock_write_on_unlocked_branch(self):
1176
1051
        backing = self.get_transport()
1177
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1052
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1178
1053
        branch = self.make_branch('.', format='knit')
1179
1054
        repository = branch.repository
1180
1055
        response = request.execute('')
1181
1056
        branch_nonce = branch.control_files._lock.peek().get('nonce')
1182
1057
        repository_nonce = repository.control_files._lock.peek().get('nonce')
1183
 
        self.assertEqual(smart_req.SmartServerResponse(
1184
 
                ('ok', branch_nonce, repository_nonce)),
1185
 
                         response)
 
1058
        self.assertEqual(
 
1059
            SmartServerResponse(('ok', branch_nonce, repository_nonce)),
 
1060
            response)
1186
1061
        # The branch (and associated repository) is now locked.  Verify that
1187
1062
        # with a new branch object.
1188
1063
        new_branch = repository.bzrdir.open_branch()
1189
1064
        self.assertRaises(errors.LockContention, new_branch.lock_write)
1190
1065
        # Cleanup
1191
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
1066
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1192
1067
        response = request.execute('', branch_nonce, repository_nonce)
1193
1068
 
1194
1069
    def test_lock_write_on_locked_branch(self):
1195
1070
        backing = self.get_transport()
1196
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1071
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1197
1072
        branch = self.make_branch('.')
1198
 
        branch_token = branch.lock_write().branch_token
 
1073
        branch_token = branch.lock_write()
1199
1074
        branch.leave_lock_in_place()
1200
1075
        branch.unlock()
1201
1076
        response = request.execute('')
1202
1077
        self.assertEqual(
1203
 
            smart_req.SmartServerResponse(('LockContention',)), response)
 
1078
            SmartServerResponse(('LockContention',)), response)
1204
1079
        # Cleanup
1205
1080
        branch.lock_write(branch_token)
1206
1081
        branch.dont_leave_lock_in_place()
1208
1083
 
1209
1084
    def test_lock_write_with_tokens_on_locked_branch(self):
1210
1085
        backing = self.get_transport()
1211
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1086
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1212
1087
        branch = self.make_branch('.', format='knit')
1213
 
        branch_token, repo_token = self.get_lock_tokens(branch)
 
1088
        branch_token = branch.lock_write()
 
1089
        repo_token = branch.repository.lock_write()
 
1090
        branch.repository.unlock()
1214
1091
        branch.leave_lock_in_place()
1215
1092
        branch.repository.leave_lock_in_place()
1216
1093
        branch.unlock()
1217
1094
        response = request.execute('',
1218
1095
                                   branch_token, repo_token)
1219
1096
        self.assertEqual(
1220
 
            smart_req.SmartServerResponse(('ok', branch_token, repo_token)),
1221
 
            response)
 
1097
            SmartServerResponse(('ok', branch_token, repo_token)), response)
1222
1098
        # Cleanup
1223
1099
        branch.repository.lock_write(repo_token)
1224
1100
        branch.repository.dont_leave_lock_in_place()
1229
1105
 
1230
1106
    def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
1231
1107
        backing = self.get_transport()
1232
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1108
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1233
1109
        branch = self.make_branch('.', format='knit')
1234
 
        branch_token, repo_token = self.get_lock_tokens(branch)
 
1110
        branch_token = branch.lock_write()
 
1111
        repo_token = branch.repository.lock_write()
 
1112
        branch.repository.unlock()
1235
1113
        branch.leave_lock_in_place()
1236
1114
        branch.repository.leave_lock_in_place()
1237
1115
        branch.unlock()
1238
1116
        response = request.execute('',
1239
1117
                                   branch_token+'xxx', repo_token)
1240
1118
        self.assertEqual(
1241
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1119
            SmartServerResponse(('TokenMismatch',)), response)
1242
1120
        # Cleanup
1243
1121
        branch.repository.lock_write(repo_token)
1244
1122
        branch.repository.dont_leave_lock_in_place()
1249
1127
 
1250
1128
    def test_lock_write_on_locked_repo(self):
1251
1129
        backing = self.get_transport()
1252
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1130
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1253
1131
        branch = self.make_branch('.', format='knit')
1254
1132
        repo = branch.repository
1255
 
        repo_token = repo.lock_write().repository_token
 
1133
        repo_token = repo.lock_write()
1256
1134
        repo.leave_lock_in_place()
1257
1135
        repo.unlock()
1258
1136
        response = request.execute('')
1259
1137
        self.assertEqual(
1260
 
            smart_req.SmartServerResponse(('LockContention',)), response)
 
1138
            SmartServerResponse(('LockContention',)), response)
1261
1139
        # Cleanup
1262
1140
        repo.lock_write(repo_token)
1263
1141
        repo.dont_leave_lock_in_place()
1265
1143
 
1266
1144
    def test_lock_write_on_readonly_transport(self):
1267
1145
        backing = self.get_readonly_transport()
1268
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1146
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1269
1147
        branch = self.make_branch('.')
1270
1148
        root = self.get_transport().clone('/')
1271
1149
        path = urlutils.relative_url(root.base, self.get_transport().base)
1275
1153
        self.assertEqual('LockFailed', error_name)
1276
1154
 
1277
1155
 
1278
 
class TestSmartServerBranchRequestUnlock(TestLockedBranch):
 
1156
class TestSmartServerBranchRequestUnlock(tests.TestCaseWithMemoryTransport):
1279
1157
 
1280
1158
    def setUp(self):
1281
1159
        tests.TestCaseWithMemoryTransport.setUp(self)
1282
1160
 
1283
1161
    def test_unlock_on_locked_branch_and_repo(self):
1284
1162
        backing = self.get_transport()
1285
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
1163
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1286
1164
        branch = self.make_branch('.', format='knit')
1287
1165
        # Lock the branch
1288
 
        branch_token, repo_token = self.get_lock_tokens(branch)
 
1166
        branch_token = branch.lock_write()
 
1167
        repo_token = branch.repository.lock_write()
 
1168
        branch.repository.unlock()
1289
1169
        # Unlock the branch (and repo) object, leaving the physical locks
1290
1170
        # in place.
1291
1171
        branch.leave_lock_in_place()
1294
1174
        response = request.execute('',
1295
1175
                                   branch_token, repo_token)
1296
1176
        self.assertEqual(
1297
 
            smart_req.SmartServerResponse(('ok',)), response)
 
1177
            SmartServerResponse(('ok',)), response)
1298
1178
        # The branch is now unlocked.  Verify that with a new branch
1299
1179
        # object.
1300
1180
        new_branch = branch.bzrdir.open_branch()
1303
1183
 
1304
1184
    def test_unlock_on_unlocked_branch_unlocked_repo(self):
1305
1185
        backing = self.get_transport()
1306
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
1186
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1307
1187
        branch = self.make_branch('.', format='knit')
1308
1188
        response = request.execute(
1309
1189
            '', 'branch token', 'repo token')
1310
1190
        self.assertEqual(
1311
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1191
            SmartServerResponse(('TokenMismatch',)), response)
1312
1192
 
1313
1193
    def test_unlock_on_unlocked_branch_locked_repo(self):
1314
1194
        backing = self.get_transport()
1315
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
1195
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1316
1196
        branch = self.make_branch('.', format='knit')
1317
1197
        # Lock the repository.
1318
 
        repo_token = branch.repository.lock_write().repository_token
 
1198
        repo_token = branch.repository.lock_write()
1319
1199
        branch.repository.leave_lock_in_place()
1320
1200
        branch.repository.unlock()
1321
1201
        # Issue branch lock_write request on the unlocked branch (with locked
1322
1202
        # repo).
1323
 
        response = request.execute('', 'branch token', repo_token)
 
1203
        response = request.execute(
 
1204
            '', 'branch token', repo_token)
1324
1205
        self.assertEqual(
1325
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1206
            SmartServerResponse(('TokenMismatch',)), response)
1326
1207
        # Cleanup
1327
1208
        branch.repository.lock_write(repo_token)
1328
1209
        branch.repository.dont_leave_lock_in_place()
1338
1219
        # its the exact path being looked at and the server is not
1339
1220
        # searching.
1340
1221
        backing = self.get_transport()
1341
 
        request = smart_repo.SmartServerRepositoryRequest(backing)
 
1222
        request = smart.repository.SmartServerRepositoryRequest(backing)
1342
1223
        self.make_repository('.', shared=True)
1343
1224
        self.make_bzrdir('subdir')
1344
1225
        self.assertRaises(errors.NoRepositoryPresent,
1350
1231
    def test_trivial_bzipped(self):
1351
1232
        # This tests that the wire encoding is actually bzipped
1352
1233
        backing = self.get_transport()
1353
 
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
 
1234
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1354
1235
        tree = self.make_branch_and_memory_tree('.')
1355
1236
 
1356
1237
        self.assertEqual(None,
1357
1238
            request.execute('', 'missing-id'))
1358
1239
        # Note that it returns a body that is bzipped.
1359
1240
        self.assertEqual(
1360
 
            smart_req.SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
 
1241
            SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1361
1242
            request.do_body('\n\n0\n'))
1362
1243
 
1363
1244
    def test_trivial_include_missing(self):
1364
1245
        backing = self.get_transport()
1365
 
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
 
1246
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1366
1247
        tree = self.make_branch_and_memory_tree('.')
1367
1248
 
1368
1249
        self.assertEqual(None,
1369
1250
            request.execute('', 'missing-id', 'include-missing:'))
1370
1251
        self.assertEqual(
1371
 
            smart_req.SuccessfulSmartServerResponse(('ok', ),
 
1252
            SuccessfulSmartServerResponse(('ok', ),
1372
1253
                bz2.compress('missing:missing-id')),
1373
1254
            request.do_body('\n\n0\n'))
1374
1255
 
1375
1256
 
1376
 
class TestSmartServerRepositoryGetRevisionGraph(
1377
 
    tests.TestCaseWithMemoryTransport):
 
1257
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
1378
1258
 
1379
1259
    def test_none_argument(self):
1380
1260
        backing = self.get_transport()
1381
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1261
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1382
1262
        tree = self.make_branch_and_memory_tree('.')
1383
1263
        tree.lock_write()
1384
1264
        tree.add('')
1393
1273
        response.body = '\n'.join(sorted(response.body.split('\n')))
1394
1274
 
1395
1275
        self.assertEqual(
1396
 
            smart_req.SmartServerResponse(('ok', ), '\n'.join(lines)), response)
 
1276
            SmartServerResponse(('ok', ), '\n'.join(lines)), response)
1397
1277
 
1398
1278
    def test_specific_revision_argument(self):
1399
1279
        backing = self.get_transport()
1400
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1280
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1401
1281
        tree = self.make_branch_and_memory_tree('.')
1402
1282
        tree.lock_write()
1403
1283
        tree.add('')
1406
1286
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1407
1287
        tree.unlock()
1408
1288
 
1409
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), rev_id_utf8),
 
1289
        self.assertEqual(SmartServerResponse(('ok', ), rev_id_utf8),
1410
1290
            request.execute('', rev_id_utf8))
1411
1291
 
1412
1292
    def test_no_such_revision(self):
1413
1293
        backing = self.get_transport()
1414
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1294
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1415
1295
        tree = self.make_branch_and_memory_tree('.')
1416
1296
        tree.lock_write()
1417
1297
        tree.add('')
1419
1299
        tree.unlock()
1420
1300
 
1421
1301
        # 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):
 
1302
        self.assertEqual(
 
1303
            SmartServerResponse(('nosuchrevision', 'missingrevision', ), ''),
 
1304
            request.execute('', 'missingrevision'))
 
1305
 
 
1306
 
 
1307
class TestSmartServerRepositoryGetRevIdForRevno(tests.TestCaseWithMemoryTransport):
1429
1308
 
1430
1309
    def test_revno_found(self):
1431
1310
        backing = self.get_transport()
1432
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
 
1311
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
1433
1312
        tree = self.make_branch_and_memory_tree('.')
1434
1313
        tree.lock_write()
1435
1314
        tree.add('')
1439
1318
        tree.commit('2nd commit', rev_id=rev2_id_utf8)
1440
1319
        tree.unlock()
1441
1320
 
1442
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', rev1_id_utf8)),
 
1321
        self.assertEqual(SmartServerResponse(('ok', rev1_id_utf8)),
1443
1322
            request.execute('', 1, (2, rev2_id_utf8)))
1444
1323
 
1445
1324
    def test_known_revid_missing(self):
1446
1325
        backing = self.get_transport()
1447
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
 
1326
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
1448
1327
        repo = self.make_repository('.')
1449
1328
        self.assertEqual(
1450
 
            smart_req.FailedSmartServerResponse(('nosuchrevision', 'ghost')),
 
1329
            FailedSmartServerResponse(('nosuchrevision', 'ghost')),
1451
1330
            request.execute('', 1, (2, 'ghost')))
1452
1331
 
1453
1332
    def test_history_incomplete(self):
1454
1333
        backing = self.get_transport()
1455
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
 
1334
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
1456
1335
        parent = self.make_branch_and_memory_tree('parent', format='1.9')
1457
1336
        parent.lock_write()
1458
1337
        parent.add([''], ['TREE_ROOT'])
1466
1345
        local.branch.create_clone_on_transport(
1467
1346
            self.get_transport('stacked'), stacked_on=self.get_url('parent'))
1468
1347
        self.assertEqual(
1469
 
            smart_req.SmartServerResponse(('history-incomplete', 2, r2)),
 
1348
            SmartServerResponse(('history-incomplete', 2, r2)),
1470
1349
            request.execute('stacked', 1, (3, r3)))
1471
1350
 
1472
1351
 
1473
 
class GetStreamTestBase(tests.TestCaseWithMemoryTransport):
 
1352
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1474
1353
 
1475
1354
    def make_two_commit_repo(self):
1476
1355
        tree = self.make_branch_and_memory_tree('.')
1482
1361
        repo = tree.branch.repository
1483
1362
        return repo, r1, r2
1484
1363
 
1485
 
 
1486
 
class TestSmartServerRepositoryGetStream(GetStreamTestBase):
1487
 
 
1488
1364
    def test_ancestry_of(self):
1489
1365
        """The search argument may be a 'ancestry-of' some heads'."""
1490
1366
        backing = self.get_transport()
1491
 
        request = smart_repo.SmartServerRepositoryGetStream(backing)
 
1367
        request = smart.repository.SmartServerRepositoryGetStream(backing)
1492
1368
        repo, r1, r2 = self.make_two_commit_repo()
1493
1369
        fetch_spec = ['ancestry-of', r2]
1494
1370
        lines = '\n'.join(fetch_spec)
1501
1377
    def test_search(self):
1502
1378
        """The search argument may be a 'search' of some explicit keys."""
1503
1379
        backing = self.get_transport()
1504
 
        request = smart_repo.SmartServerRepositoryGetStream(backing)
 
1380
        request = smart.repository.SmartServerRepositoryGetStream(backing)
1505
1381
        repo, r1, r2 = self.make_two_commit_repo()
1506
1382
        fetch_spec = ['search', '%s %s' % (r1, r2), 'null:', '2']
1507
1383
        lines = '\n'.join(fetch_spec)
1511
1387
        stream_bytes = ''.join(response.body_stream)
1512
1388
        self.assertStartsWith(stream_bytes, 'Bazaar pack format 1')
1513
1389
 
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
1390
 
1527
1391
class TestSmartServerRequestHasRevision(tests.TestCaseWithMemoryTransport):
1528
1392
 
1529
1393
    def test_missing_revision(self):
1530
1394
        """For a missing revision, ('no', ) is returned."""
1531
1395
        backing = self.get_transport()
1532
 
        request = smart_repo.SmartServerRequestHasRevision(backing)
 
1396
        request = smart.repository.SmartServerRequestHasRevision(backing)
1533
1397
        self.make_repository('.')
1534
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1398
        self.assertEqual(SmartServerResponse(('no', )),
1535
1399
            request.execute('', 'revid'))
1536
1400
 
1537
1401
    def test_present_revision(self):
1538
1402
        """For a present revision, ('yes', ) is returned."""
1539
1403
        backing = self.get_transport()
1540
 
        request = smart_repo.SmartServerRequestHasRevision(backing)
 
1404
        request = smart.repository.SmartServerRequestHasRevision(backing)
1541
1405
        tree = self.make_branch_and_memory_tree('.')
1542
1406
        tree.lock_write()
1543
1407
        tree.add('')
1545
1409
        r1 = tree.commit('a commit', rev_id=rev_id_utf8)
1546
1410
        tree.unlock()
1547
1411
        self.assertTrue(tree.branch.repository.has_revision(rev_id_utf8))
1548
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1412
        self.assertEqual(SmartServerResponse(('yes', )),
1549
1413
            request.execute('', rev_id_utf8))
1550
1414
 
1551
1415
 
1554
1418
    def test_empty_revid(self):
1555
1419
        """With an empty revid, we get only size an number and revisions"""
1556
1420
        backing = self.get_transport()
1557
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1421
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1558
1422
        repository = self.make_repository('.')
1559
1423
        stats = repository.gather_stats()
1560
1424
        expected_body = 'revisions: 0\n'
1561
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1425
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1562
1426
                         request.execute('', '', 'no'))
1563
1427
 
1564
1428
    def test_revid_with_committers(self):
1565
1429
        """For a revid we get more infos."""
1566
1430
        backing = self.get_transport()
1567
1431
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1568
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1432
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1569
1433
        tree = self.make_branch_and_memory_tree('.')
1570
1434
        tree.lock_write()
1571
1435
        tree.add('')
1579
1443
        expected_body = ('firstrev: 123456.200 3600\n'
1580
1444
                         'latestrev: 654321.400 0\n'
1581
1445
                         'revisions: 2\n')
1582
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1446
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1583
1447
                         request.execute('',
1584
1448
                                         rev_id_utf8, 'no'))
1585
1449
 
1587
1451
        """For a revid and requesting committers we get the whole thing."""
1588
1452
        backing = self.get_transport()
1589
1453
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1590
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1454
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1591
1455
        tree = self.make_branch_and_memory_tree('.')
1592
1456
        tree.lock_write()
1593
1457
        tree.add('')
1603
1467
                         'firstrev: 123456.200 3600\n'
1604
1468
                         'latestrev: 654321.400 0\n'
1605
1469
                         'revisions: 2\n')
1606
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1470
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1607
1471
                         request.execute('',
1608
1472
                                         rev_id_utf8, 'yes'))
1609
1473
 
1613
1477
    def test_is_shared(self):
1614
1478
        """For a shared repository, ('yes', ) is returned."""
1615
1479
        backing = self.get_transport()
1616
 
        request = smart_repo.SmartServerRepositoryIsShared(backing)
 
1480
        request = smart.repository.SmartServerRepositoryIsShared(backing)
1617
1481
        self.make_repository('.', shared=True)
1618
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1482
        self.assertEqual(SmartServerResponse(('yes', )),
1619
1483
            request.execute('', ))
1620
1484
 
1621
1485
    def test_is_not_shared(self):
1622
1486
        """For a shared repository, ('no', ) is returned."""
1623
1487
        backing = self.get_transport()
1624
 
        request = smart_repo.SmartServerRepositoryIsShared(backing)
 
1488
        request = smart.repository.SmartServerRepositoryIsShared(backing)
1625
1489
        self.make_repository('.', shared=False)
1626
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1490
        self.assertEqual(SmartServerResponse(('no', )),
1627
1491
            request.execute('', ))
1628
1492
 
1629
1493
 
1631
1495
 
1632
1496
    def test_lock_write_on_unlocked_repo(self):
1633
1497
        backing = self.get_transport()
1634
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1498
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1635
1499
        repository = self.make_repository('.', format='knit')
1636
1500
        response = request.execute('')
1637
1501
        nonce = repository.control_files._lock.peek().get('nonce')
1638
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
 
1502
        self.assertEqual(SmartServerResponse(('ok', nonce)), response)
1639
1503
        # The repository is now locked.  Verify that with a new repository
1640
1504
        # object.
1641
1505
        new_repo = repository.bzrdir.open_repository()
1642
1506
        self.assertRaises(errors.LockContention, new_repo.lock_write)
1643
1507
        # Cleanup
1644
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1508
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1645
1509
        response = request.execute('', nonce)
1646
1510
 
1647
1511
    def test_lock_write_on_locked_repo(self):
1648
1512
        backing = self.get_transport()
1649
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1513
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1650
1514
        repository = self.make_repository('.', format='knit')
1651
 
        repo_token = repository.lock_write().repository_token
 
1515
        repo_token = repository.lock_write()
1652
1516
        repository.leave_lock_in_place()
1653
1517
        repository.unlock()
1654
1518
        response = request.execute('')
1655
1519
        self.assertEqual(
1656
 
            smart_req.SmartServerResponse(('LockContention',)), response)
 
1520
            SmartServerResponse(('LockContention',)), response)
1657
1521
        # Cleanup
1658
1522
        repository.lock_write(repo_token)
1659
1523
        repository.dont_leave_lock_in_place()
1661
1525
 
1662
1526
    def test_lock_write_on_readonly_transport(self):
1663
1527
        backing = self.get_readonly_transport()
1664
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1528
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1665
1529
        repository = self.make_repository('.', format='knit')
1666
1530
        response = request.execute('')
1667
1531
        self.assertFalse(response.is_successful())
1671
1535
class TestInsertStreamBase(tests.TestCaseWithMemoryTransport):
1672
1536
 
1673
1537
    def make_empty_byte_stream(self, repo):
1674
 
        byte_stream = smart_repo._stream_to_byte_stream([], repo._format)
 
1538
        byte_stream = smart.repository._stream_to_byte_stream([], repo._format)
1675
1539
        return ''.join(byte_stream)
1676
1540
 
1677
1541
 
1679
1543
 
1680
1544
    def test_insert_stream_empty(self):
1681
1545
        backing = self.get_transport()
1682
 
        request = smart_repo.SmartServerRepositoryInsertStream(backing)
 
1546
        request = smart.repository.SmartServerRepositoryInsertStream(backing)
1683
1547
        repository = self.make_repository('.')
1684
1548
        response = request.execute('', '')
1685
1549
        self.assertEqual(None, response)
1686
1550
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1687
1551
        self.assertEqual(None, response)
1688
1552
        response = request.do_end()
1689
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1690
 
 
 
1553
        self.assertEqual(SmartServerResponse(('ok', )), response)
 
1554
        
1691
1555
 
1692
1556
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
1693
1557
 
1694
1558
    def test_insert_stream_empty(self):
1695
1559
        backing = self.get_transport()
1696
 
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
 
1560
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1697
1561
            backing)
1698
1562
        repository = self.make_repository('.', format='knit')
1699
 
        lock_token = repository.lock_write().repository_token
 
1563
        lock_token = repository.lock_write()
1700
1564
        response = request.execute('', '', lock_token)
1701
1565
        self.assertEqual(None, response)
1702
1566
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1703
1567
        self.assertEqual(None, response)
1704
1568
        response = request.do_end()
1705
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
 
1569
        self.assertEqual(SmartServerResponse(('ok', )), response)
1706
1570
        repository.unlock()
1707
1571
 
1708
1572
    def test_insert_stream_with_wrong_lock_token(self):
1709
1573
        backing = self.get_transport()
1710
 
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
 
1574
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1711
1575
            backing)
1712
1576
        repository = self.make_repository('.', format='knit')
1713
 
        lock_token = repository.lock_write().repository_token
 
1577
        lock_token = repository.lock_write()
1714
1578
        self.assertRaises(
1715
1579
            errors.TokenMismatch, request.execute, '', '', 'wrong-token')
1716
1580
        repository.unlock()
1723
1587
 
1724
1588
    def test_unlock_on_locked_repo(self):
1725
1589
        backing = self.get_transport()
1726
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1590
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1727
1591
        repository = self.make_repository('.', format='knit')
1728
 
        token = repository.lock_write().repository_token
 
1592
        token = repository.lock_write()
1729
1593
        repository.leave_lock_in_place()
1730
1594
        repository.unlock()
1731
1595
        response = request.execute('', token)
1732
1596
        self.assertEqual(
1733
 
            smart_req.SmartServerResponse(('ok',)), response)
 
1597
            SmartServerResponse(('ok',)), response)
1734
1598
        # The repository is now unlocked.  Verify that with a new repository
1735
1599
        # object.
1736
1600
        new_repo = repository.bzrdir.open_repository()
1739
1603
 
1740
1604
    def test_unlock_on_unlocked_repo(self):
1741
1605
        backing = self.get_transport()
1742
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1606
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1743
1607
        repository = self.make_repository('.', format='knit')
1744
1608
        response = request.execute('', 'some token')
1745
1609
        self.assertEqual(
1746
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1610
            SmartServerResponse(('TokenMismatch',)), response)
1747
1611
 
1748
1612
 
1749
1613
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1750
1614
 
1751
1615
    def test_is_readonly_no(self):
1752
1616
        backing = self.get_transport()
1753
 
        request = smart_req.SmartServerIsReadonly(backing)
 
1617
        request = smart.request.SmartServerIsReadonly(backing)
1754
1618
        response = request.execute()
1755
1619
        self.assertEqual(
1756
 
            smart_req.SmartServerResponse(('no',)), response)
 
1620
            SmartServerResponse(('no',)), response)
1757
1621
 
1758
1622
    def test_is_readonly_yes(self):
1759
1623
        backing = self.get_readonly_transport()
1760
 
        request = smart_req.SmartServerIsReadonly(backing)
 
1624
        request = smart.request.SmartServerIsReadonly(backing)
1761
1625
        response = request.execute()
1762
1626
        self.assertEqual(
1763
 
            smart_req.SmartServerResponse(('yes',)), response)
1764
 
 
1765
 
 
1766
 
class TestSmartServerRepositorySetMakeWorkingTrees(
1767
 
    tests.TestCaseWithMemoryTransport):
 
1627
            SmartServerResponse(('yes',)), response)
 
1628
 
 
1629
 
 
1630
class TestSmartServerRepositorySetMakeWorkingTrees(tests.TestCaseWithMemoryTransport):
1768
1631
 
1769
1632
    def test_set_false(self):
1770
1633
        backing = self.get_transport()
1771
1634
        repo = self.make_repository('.', shared=True)
1772
1635
        repo.set_make_working_trees(True)
1773
 
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
 
1636
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1774
1637
        request = request_class(backing)
1775
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1638
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1776
1639
            request.execute('', 'False'))
1777
1640
        repo = repo.bzrdir.open_repository()
1778
1641
        self.assertFalse(repo.make_working_trees())
1781
1644
        backing = self.get_transport()
1782
1645
        repo = self.make_repository('.', shared=True)
1783
1646
        repo.set_make_working_trees(False)
1784
 
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
 
1647
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1785
1648
        request = request_class(backing)
1786
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1649
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1787
1650
            request.execute('', 'True'))
1788
1651
        repo = repo.bzrdir.open_repository()
1789
1652
        self.assertTrue(repo.make_working_trees())
1808
1671
        repo.lock_write()
1809
1672
        self.addCleanup(repo.unlock)
1810
1673
        backing = self.get_transport()
1811
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1674
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1812
1675
            backing)
1813
1676
        response = request.execute('')
1814
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1677
        self.assertEqual(SmartServerResponse(('ok',)), response)
1815
1678
        repo._pack_collection.reload_pack_names()
1816
1679
        self.assertEqual(1, len(repo._pack_collection.names()))
1817
1680
 
1823
1686
        for x in range(9):
1824
1687
            tree.commit('commit %s' % x)
1825
1688
        backing = self.get_transport()
1826
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1689
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1827
1690
            backing)
1828
1691
        response = request.execute('')
1829
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1692
        self.assertEqual(SmartServerResponse(('ok',)), response)
1830
1693
        repo._pack_collection.reload_pack_names()
1831
1694
        self.assertEqual(9, len(repo._pack_collection.names()))
1832
1695
 
1834
1697
        """A request to autopack a non-pack repo is a no-op."""
1835
1698
        repo = self.make_repository('.', format='knit')
1836
1699
        backing = self.get_transport()
1837
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1700
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1838
1701
            backing)
1839
1702
        response = request.execute('')
1840
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1703
        self.assertEqual(SmartServerResponse(('ok',)), response)
1841
1704
 
1842
1705
 
1843
1706
class TestSmartServerVfsGet(tests.TestCaseWithMemoryTransport):
1847
1710
        filename = u'foo\N{INTERROBANG}'
1848
1711
        filename_escaped = urlutils.escape(filename)
1849
1712
        backing = self.get_transport()
1850
 
        request = vfs.GetRequest(backing)
 
1713
        request = smart.vfs.GetRequest(backing)
1851
1714
        backing.put_bytes_non_atomic(filename_escaped, 'contents')
1852
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'contents'),
 
1715
        self.assertEqual(SmartServerResponse(('ok', ), 'contents'),
1853
1716
            request.execute(filename_escaped))
1854
1717
 
1855
1718
 
1860
1723
        """All registered request_handlers can be found."""
1861
1724
        # If there's a typo in a register_lazy call, this loop will fail with
1862
1725
        # an AttributeError.
1863
 
        for key, item in smart_req.request_handlers.iteritems():
 
1726
        for key, item in smart.request.request_handlers.iteritems():
1864
1727
            pass
1865
1728
 
1866
1729
    def assertHandlerEqual(self, verb, handler):
1867
 
        self.assertEqual(smart_req.request_handlers.get(verb), handler)
 
1730
        self.assertEqual(smart.request.request_handlers.get(verb), handler)
1868
1731
 
1869
1732
    def test_registered_methods(self):
1870
1733
        """Test that known methods are registered to the correct object."""
1871
1734
        self.assertHandlerEqual('Branch.get_config_file',
1872
 
            smart_branch.SmartServerBranchGetConfigFile)
 
1735
            smart.branch.SmartServerBranchGetConfigFile)
1873
1736
        self.assertHandlerEqual('Branch.get_parent',
1874
 
            smart_branch.SmartServerBranchGetParent)
 
1737
            smart.branch.SmartServerBranchGetParent)
1875
1738
        self.assertHandlerEqual('Branch.get_tags_bytes',
1876
 
            smart_branch.SmartServerBranchGetTagsBytes)
 
1739
            smart.branch.SmartServerBranchGetTagsBytes)
1877
1740
        self.assertHandlerEqual('Branch.lock_write',
1878
 
            smart_branch.SmartServerBranchRequestLockWrite)
 
1741
            smart.branch.SmartServerBranchRequestLockWrite)
1879
1742
        self.assertHandlerEqual('Branch.last_revision_info',
1880
 
            smart_branch.SmartServerBranchRequestLastRevisionInfo)
 
1743
            smart.branch.SmartServerBranchRequestLastRevisionInfo)
1881
1744
        self.assertHandlerEqual('Branch.revision_history',
1882
 
            smart_branch.SmartServerRequestRevisionHistory)
 
1745
            smart.branch.SmartServerRequestRevisionHistory)
1883
1746
        self.assertHandlerEqual('Branch.set_config_option',
1884
 
            smart_branch.SmartServerBranchRequestSetConfigOption)
 
1747
            smart.branch.SmartServerBranchRequestSetConfigOption)
1885
1748
        self.assertHandlerEqual('Branch.set_last_revision',
1886
 
            smart_branch.SmartServerBranchRequestSetLastRevision)
 
1749
            smart.branch.SmartServerBranchRequestSetLastRevision)
1887
1750
        self.assertHandlerEqual('Branch.set_last_revision_info',
1888
 
            smart_branch.SmartServerBranchRequestSetLastRevisionInfo)
 
1751
            smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
1889
1752
        self.assertHandlerEqual('Branch.set_last_revision_ex',
1890
 
            smart_branch.SmartServerBranchRequestSetLastRevisionEx)
 
1753
            smart.branch.SmartServerBranchRequestSetLastRevisionEx)
1891
1754
        self.assertHandlerEqual('Branch.set_parent_location',
1892
 
            smart_branch.SmartServerBranchRequestSetParentLocation)
 
1755
            smart.branch.SmartServerBranchRequestSetParentLocation)
1893
1756
        self.assertHandlerEqual('Branch.unlock',
1894
 
            smart_branch.SmartServerBranchRequestUnlock)
 
1757
            smart.branch.SmartServerBranchRequestUnlock)
1895
1758
        self.assertHandlerEqual('BzrDir.find_repository',
1896
 
            smart_dir.SmartServerRequestFindRepositoryV1)
 
1759
            smart.bzrdir.SmartServerRequestFindRepositoryV1)
1897
1760
        self.assertHandlerEqual('BzrDir.find_repositoryV2',
1898
 
            smart_dir.SmartServerRequestFindRepositoryV2)
 
1761
            smart.bzrdir.SmartServerRequestFindRepositoryV2)
1899
1762
        self.assertHandlerEqual('BzrDirFormat.initialize',
1900
 
            smart_dir.SmartServerRequestInitializeBzrDir)
 
1763
            smart.bzrdir.SmartServerRequestInitializeBzrDir)
1901
1764
        self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
1902
 
            smart_dir.SmartServerRequestBzrDirInitializeEx)
 
1765
            smart.bzrdir.SmartServerRequestBzrDirInitializeEx)
1903
1766
        self.assertHandlerEqual('BzrDir.cloning_metadir',
1904
 
            smart_dir.SmartServerBzrDirRequestCloningMetaDir)
 
1767
            smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
1905
1768
        self.assertHandlerEqual('BzrDir.get_config_file',
1906
 
            smart_dir.SmartServerBzrDirRequestConfigFile)
 
1769
            smart.bzrdir.SmartServerBzrDirRequestConfigFile)
1907
1770
        self.assertHandlerEqual('BzrDir.open_branch',
1908
 
            smart_dir.SmartServerRequestOpenBranch)
 
1771
            smart.bzrdir.SmartServerRequestOpenBranch)
1909
1772
        self.assertHandlerEqual('BzrDir.open_branchV2',
1910
 
            smart_dir.SmartServerRequestOpenBranchV2)
1911
 
        self.assertHandlerEqual('BzrDir.open_branchV3',
1912
 
            smart_dir.SmartServerRequestOpenBranchV3)
 
1773
            smart.bzrdir.SmartServerRequestOpenBranchV2)
1913
1774
        self.assertHandlerEqual('PackRepository.autopack',
1914
 
            smart_packrepo.SmartServerPackRepositoryAutopack)
 
1775
            smart.packrepository.SmartServerPackRepositoryAutopack)
1915
1776
        self.assertHandlerEqual('Repository.gather_stats',
1916
 
            smart_repo.SmartServerRepositoryGatherStats)
 
1777
            smart.repository.SmartServerRepositoryGatherStats)
1917
1778
        self.assertHandlerEqual('Repository.get_parent_map',
1918
 
            smart_repo.SmartServerRepositoryGetParentMap)
 
1779
            smart.repository.SmartServerRepositoryGetParentMap)
1919
1780
        self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1920
 
            smart_repo.SmartServerRepositoryGetRevIdForRevno)
 
1781
            smart.repository.SmartServerRepositoryGetRevIdForRevno)
1921
1782
        self.assertHandlerEqual('Repository.get_revision_graph',
1922
 
            smart_repo.SmartServerRepositoryGetRevisionGraph)
 
1783
            smart.repository.SmartServerRepositoryGetRevisionGraph)
1923
1784
        self.assertHandlerEqual('Repository.get_stream',
1924
 
            smart_repo.SmartServerRepositoryGetStream)
1925
 
        self.assertHandlerEqual('Repository.get_stream_1.19',
1926
 
            smart_repo.SmartServerRepositoryGetStream_1_19)
 
1785
            smart.repository.SmartServerRepositoryGetStream)
1927
1786
        self.assertHandlerEqual('Repository.has_revision',
1928
 
            smart_repo.SmartServerRequestHasRevision)
 
1787
            smart.repository.SmartServerRequestHasRevision)
1929
1788
        self.assertHandlerEqual('Repository.insert_stream',
1930
 
            smart_repo.SmartServerRepositoryInsertStream)
 
1789
            smart.repository.SmartServerRepositoryInsertStream)
1931
1790
        self.assertHandlerEqual('Repository.insert_stream_locked',
1932
 
            smart_repo.SmartServerRepositoryInsertStreamLocked)
 
1791
            smart.repository.SmartServerRepositoryInsertStreamLocked)
1933
1792
        self.assertHandlerEqual('Repository.is_shared',
1934
 
            smart_repo.SmartServerRepositoryIsShared)
 
1793
            smart.repository.SmartServerRepositoryIsShared)
1935
1794
        self.assertHandlerEqual('Repository.lock_write',
1936
 
            smart_repo.SmartServerRepositoryLockWrite)
 
1795
            smart.repository.SmartServerRepositoryLockWrite)
1937
1796
        self.assertHandlerEqual('Repository.tarball',
1938
 
            smart_repo.SmartServerRepositoryTarball)
 
1797
            smart.repository.SmartServerRepositoryTarball)
1939
1798
        self.assertHandlerEqual('Repository.unlock',
1940
 
            smart_repo.SmartServerRepositoryUnlock)
 
1799
            smart.repository.SmartServerRepositoryUnlock)
1941
1800
        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/')])
 
1801
            smart.request.SmartServerIsReadonly)