← 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: INADA Naoki
  • Date: 2011-05-18 06:01:08 UTC
  • mto: This revision was merged to the branch mainline in revision 5894.
  • Revision ID: songofacandy@gmail.com-20110518060108-86t2kffcrzu0nf6i
Update Japanese docs.

Show diffs side-by-side

added added

removed removed

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