← 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: Canonical.com Patch Queue Manager
  • Date: 2009-04-09 20:23:07 UTC
  • mfrom: (4265.1.4 bbc-merge)
  • Revision ID: pqm@pqm.ubuntu.com-20090409202307-n0depb16qepoe21o
(jam) Change _fetch_uses_deltas = False for CHK repos until we can
        write a better fix.

Show diffs side-by-side

added added

removed removed

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