← 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: Vincent Ladeuil
  • Date: 2017-01-30 14:30:10 UTC
  • mfrom: (6615.3.7 merges)
  • mto: This revision was merged to the branch mainline in revision 6621.
  • Revision ID: v.ladeuil+lp@free.fr-20170130143010-p31t1ranfeqbaeki
Merge  2.7 into trunk including fix for bug #1657238

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 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
import zlib
30
29
 
31
30
from bzrlib import (
32
31
    bencode,
33
 
    bzrdir,
 
32
    branch as _mod_branch,
 
33
    controldir,
34
34
    errors,
35
 
    pack,
36
 
    smart,
 
35
    gpg,
 
36
    inventory_delta,
37
37
    tests,
 
38
    transport,
38
39
    urlutils,
39
 
    )
40
 
from bzrlib.branch import Branch, BranchReferenceFormat
41
 
import bzrlib.smart.branch
42
 
import bzrlib.smart.bzrdir, bzrlib.smart.bzrdir as smart_dir
43
 
import bzrlib.smart.packrepository
44
 
import bzrlib.smart.repository
45
 
from bzrlib.smart.request import (
46
 
    FailedSmartServerResponse,
47
 
    SmartServerRequest,
48
 
    SmartServerResponse,
49
 
    SuccessfulSmartServerResponse,
50
 
    )
51
 
from bzrlib.tests import (
52
 
    split_suite_by_re,
53
 
    )
54
 
from bzrlib.transport import chroot, get_transport
 
40
    versionedfile,
 
41
    )
 
42
from bzrlib.smart import (
 
43
    branch as smart_branch,
 
44
    bzrdir as smart_dir,
 
45
    repository as smart_repo,
 
46
    packrepository as smart_packrepo,
 
47
    request as smart_req,
 
48
    server,
 
49
    vfs,
 
50
    )
 
51
from bzrlib.testament import Testament
 
52
from bzrlib.tests import test_server
 
53
from bzrlib.transport import (
 
54
    chroot,
 
55
    memory,
 
56
    )
55
57
 
56
58
 
57
59
def load_tests(standard_tests, module, loader):
58
60
    """Multiply tests version and protocol consistency."""
59
61
    # FindRepository tests.
60
 
    bzrdir_mod = bzrlib.smart.bzrdir
61
62
    scenarios = [
62
63
        ("find_repository", {
63
 
            "_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV1}),
 
64
            "_request_class": smart_dir.SmartServerRequestFindRepositoryV1}),
64
65
        ("find_repositoryV2", {
65
 
            "_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV2}),
 
66
            "_request_class": smart_dir.SmartServerRequestFindRepositoryV2}),
66
67
        ("find_repositoryV3", {
67
 
            "_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV3}),
 
68
            "_request_class": smart_dir.SmartServerRequestFindRepositoryV3}),
68
69
        ]
69
 
    to_adapt, result = split_suite_by_re(standard_tests,
 
70
    to_adapt, result = tests.split_suite_by_re(standard_tests,
70
71
        "TestSmartServerRequestFindRepository")
71
 
    v2_only, v1_and_2 = split_suite_by_re(to_adapt,
 
72
    v2_only, v1_and_2 = tests.split_suite_by_re(to_adapt,
72
73
        "_v2")
73
74
    tests.multiply_tests(v1_and_2, scenarios, result)
74
75
    # The first scenario is only applicable to v1 protocols, it is deleted
80
81
class TestCaseWithChrootedTransport(tests.TestCaseWithTransport):
81
82
 
82
83
    def setUp(self):
83
 
        tests.TestCaseWithTransport.setUp(self)
 
84
        self.vfs_transport_factory = memory.MemoryServer
 
85
        super(TestCaseWithChrootedTransport, self).setUp()
84
86
        self._chroot_server = None
85
87
 
86
88
    def get_transport(self, relpath=None):
87
89
        if self._chroot_server is None:
88
90
            backing_transport = tests.TestCaseWithTransport.get_transport(self)
89
91
            self._chroot_server = chroot.ChrootServer(backing_transport)
90
 
            self._chroot_server.setUp()
91
 
            self.addCleanup(self._chroot_server.tearDown)
92
 
        t = get_transport(self._chroot_server.get_url())
 
92
            self.start_server(self._chroot_server)
 
93
        t = transport.get_transport_from_url(self._chroot_server.get_url())
93
94
        if relpath is not None:
94
95
            t = t.clone(relpath)
95
96
        return t
96
97
 
97
98
 
98
 
class TestCaseWithSmartMedium(tests.TestCaseWithTransport):
 
99
class TestCaseWithSmartMedium(tests.TestCaseWithMemoryTransport):
99
100
 
100
101
    def setUp(self):
101
102
        super(TestCaseWithSmartMedium, self).setUp()
103
104
        # the default or a parameterized class, but rather use the
104
105
        # TestCaseWithTransport infrastructure to set up a smart server and
105
106
        # transport.
106
 
        self.transport_server = self.make_transport_server
 
107
        self.overrideAttr(self, "transport_server", self.make_transport_server)
107
108
 
108
109
    def make_transport_server(self):
109
 
        return smart.server.SmartTCPServer_for_testing('-' + self.id())
 
110
        return test_server.SmartTCPServer_for_testing('-' + self.id())
110
111
 
111
112
    def get_smart_medium(self):
112
113
        """Get a smart medium to use in tests."""
113
114
        return self.get_transport().get_smart_medium()
114
115
 
115
116
 
 
117
class TestByteStreamToStream(tests.TestCase):
 
118
 
 
119
    def test_repeated_substreams_same_kind_are_one_stream(self):
 
120
        # Make a stream - an iterable of bytestrings.
 
121
        stream = [('text', [versionedfile.FulltextContentFactory(('k1',), None,
 
122
            None, 'foo')]),('text', [
 
123
            versionedfile.FulltextContentFactory(('k2',), None, None, 'bar')])]
 
124
        fmt = controldir.format_registry.get('pack-0.92')().repository_format
 
125
        bytes = smart_repo._stream_to_byte_stream(stream, fmt)
 
126
        streams = []
 
127
        # Iterate the resulting iterable; checking that we get only one stream
 
128
        # out.
 
129
        fmt, stream = smart_repo._byte_stream_to_stream(bytes)
 
130
        for kind, substream in stream:
 
131
            streams.append((kind, list(substream)))
 
132
        self.assertLength(1, streams)
 
133
        self.assertLength(2, streams[0][1])
 
134
 
 
135
 
116
136
class TestSmartServerResponse(tests.TestCase):
117
137
 
118
138
    def test__eq__(self):
119
 
        self.assertEqual(SmartServerResponse(('ok', )),
120
 
            SmartServerResponse(('ok', )))
121
 
        self.assertEqual(SmartServerResponse(('ok', ), 'body'),
122
 
            SmartServerResponse(('ok', ), 'body'))
123
 
        self.assertNotEqual(SmartServerResponse(('ok', )),
124
 
            SmartServerResponse(('notok', )))
125
 
        self.assertNotEqual(SmartServerResponse(('ok', ), 'body'),
126
 
            SmartServerResponse(('ok', )))
 
139
        self.assertEqual(smart_req.SmartServerResponse(('ok', )),
 
140
            smart_req.SmartServerResponse(('ok', )))
 
141
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'body'),
 
142
            smart_req.SmartServerResponse(('ok', ), 'body'))
 
143
        self.assertNotEqual(smart_req.SmartServerResponse(('ok', )),
 
144
            smart_req.SmartServerResponse(('notok', )))
 
145
        self.assertNotEqual(smart_req.SmartServerResponse(('ok', ), 'body'),
 
146
            smart_req.SmartServerResponse(('ok', )))
127
147
        self.assertNotEqual(None,
128
 
            SmartServerResponse(('ok', )))
 
148
            smart_req.SmartServerResponse(('ok', )))
129
149
 
130
150
    def test__str__(self):
131
151
        """SmartServerResponses can be stringified."""
132
152
        self.assertEqual(
133
153
            "<SuccessfulSmartServerResponse args=('args',) body='body'>",
134
 
            str(SuccessfulSmartServerResponse(('args',), 'body')))
 
154
            str(smart_req.SuccessfulSmartServerResponse(('args',), 'body')))
135
155
        self.assertEqual(
136
156
            "<FailedSmartServerResponse args=('args',) body='body'>",
137
 
            str(FailedSmartServerResponse(('args',), 'body')))
 
157
            str(smart_req.FailedSmartServerResponse(('args',), 'body')))
138
158
 
139
159
 
140
160
class TestSmartServerRequest(tests.TestCaseWithMemoryTransport):
141
161
 
142
162
    def test_translate_client_path(self):
143
163
        transport = self.get_transport()
144
 
        request = SmartServerRequest(transport, 'foo/')
 
164
        request = smart_req.SmartServerRequest(transport, 'foo/')
145
165
        self.assertEqual('./', request.translate_client_path('foo/'))
146
166
        self.assertRaises(
147
167
            errors.InvalidURLJoin, request.translate_client_path, 'foo/..')
150
170
        self.assertRaises(
151
171
            errors.PathNotChild, request.translate_client_path, 'bar/')
152
172
        self.assertEqual('./baz', request.translate_client_path('foo/baz'))
 
173
        e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'.encode('utf-8')
 
174
        self.assertEqual('./' + urlutils.escape(e_acute),
 
175
                         request.translate_client_path('foo/' + e_acute))
 
176
 
 
177
    def test_translate_client_path_vfs(self):
 
178
        """VfsRequests receive escaped paths rather than raw UTF-8."""
 
179
        transport = self.get_transport()
 
180
        request = vfs.VfsRequest(transport, 'foo/')
 
181
        e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'.encode('utf-8')
 
182
        escaped = urlutils.escape('foo/' + e_acute)
 
183
        self.assertEqual('./' + urlutils.escape(e_acute),
 
184
                         request.translate_client_path(escaped))
153
185
 
154
186
    def test_transport_from_client_path(self):
155
187
        transport = self.get_transport()
156
 
        request = SmartServerRequest(transport, 'foo/')
 
188
        request = smart_req.SmartServerRequest(transport, 'foo/')
157
189
        self.assertEqual(
158
190
            transport.base,
159
191
            request.transport_from_client_path('foo/').base)
170
202
        local_result = dir.cloning_metadir()
171
203
        request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
172
204
        request = request_class(backing)
173
 
        expected = SuccessfulSmartServerResponse(
 
205
        expected = smart_req.SuccessfulSmartServerResponse(
174
206
            (local_result.network_name(),
175
207
            local_result.repository_format.network_name(),
176
208
            ('branch', local_result.get_branch_format().network_name())))
182
214
        referenced_branch = self.make_branch('referenced')
183
215
        dir = self.make_bzrdir('.')
184
216
        local_result = dir.cloning_metadir()
185
 
        reference = BranchReferenceFormat().initialize(dir, referenced_branch)
186
 
        reference_url = BranchReferenceFormat().get_reference(dir)
 
217
        reference = _mod_branch.BranchReferenceFormat().initialize(
 
218
            dir, target_branch=referenced_branch)
 
219
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(dir)
187
220
        # The server shouldn't try to follow the branch reference, so it's fine
188
221
        # if the referenced branch isn't reachable.
189
222
        backing.rename('referenced', 'moved')
190
223
        request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
191
224
        request = request_class(backing)
192
 
        expected = FailedSmartServerResponse(('BranchReference',))
 
225
        expected = smart_req.FailedSmartServerResponse(('BranchReference',))
193
226
        self.assertEqual(expected, request.execute('', 'False'))
194
227
 
195
228
 
 
229
class TestSmartServerBzrDirRequestCloningMetaDir(
 
230
    tests.TestCaseWithMemoryTransport):
 
231
    """Tests for BzrDir.checkout_metadir."""
 
232
 
 
233
    def test_checkout_metadir(self):
 
234
        backing = self.get_transport()
 
235
        request = smart_dir.SmartServerBzrDirRequestCheckoutMetaDir(
 
236
            backing)
 
237
        branch = self.make_branch('.', format='2a')
 
238
        response = request.execute('')
 
239
        self.assertEqual(
 
240
            smart_req.SmartServerResponse(
 
241
                ('Bazaar-NG meta directory, format 1\n',
 
242
                 'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
 
243
                 'Bazaar Branch Format 7 (needs bzr 1.6)\n')),
 
244
            response)
 
245
 
 
246
 
 
247
class TestSmartServerBzrDirRequestDestroyBranch(
 
248
    tests.TestCaseWithMemoryTransport):
 
249
    """Tests for BzrDir.destroy_branch."""
 
250
 
 
251
    def test_destroy_branch_default(self):
 
252
        """The default branch can be removed."""
 
253
        backing = self.get_transport()
 
254
        dir = self.make_branch('.').bzrdir
 
255
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
 
256
        request = request_class(backing)
 
257
        expected = smart_req.SuccessfulSmartServerResponse(('ok',))
 
258
        self.assertEqual(expected, request.execute('', None))
 
259
 
 
260
    def test_destroy_branch_named(self):
 
261
        """A named branch can be removed."""
 
262
        backing = self.get_transport()
 
263
        dir = self.make_repository('.', format="development-colo").bzrdir
 
264
        dir.create_branch(name="branchname")
 
265
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
 
266
        request = request_class(backing)
 
267
        expected = smart_req.SuccessfulSmartServerResponse(('ok',))
 
268
        self.assertEqual(expected, request.execute('', "branchname"))
 
269
 
 
270
    def test_destroy_branch_missing(self):
 
271
        """An error is raised if the branch didn't exist."""
 
272
        backing = self.get_transport()
 
273
        dir = self.make_bzrdir('.', format="development-colo")
 
274
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
 
275
        request = request_class(backing)
 
276
        expected = smart_req.FailedSmartServerResponse(('nobranch',), None)
 
277
        self.assertEqual(expected, request.execute('', "branchname"))
 
278
 
 
279
 
 
280
class TestSmartServerBzrDirRequestHasWorkingTree(
 
281
    tests.TestCaseWithTransport):
 
282
    """Tests for BzrDir.has_workingtree."""
 
283
 
 
284
    def test_has_workingtree_yes(self):
 
285
        """A working tree is present."""
 
286
        backing = self.get_transport()
 
287
        dir = self.make_branch_and_tree('.').bzrdir
 
288
        request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
 
289
        request = request_class(backing)
 
290
        expected = smart_req.SuccessfulSmartServerResponse(('yes',))
 
291
        self.assertEqual(expected, request.execute(''))
 
292
 
 
293
    def test_has_workingtree_no(self):
 
294
        """A working tree is missing."""
 
295
        backing = self.get_transport()
 
296
        dir = self.make_bzrdir('.')
 
297
        request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
 
298
        request = request_class(backing)
 
299
        expected = smart_req.SuccessfulSmartServerResponse(('no',))
 
300
        self.assertEqual(expected, request.execute(''))
 
301
 
 
302
 
 
303
class TestSmartServerBzrDirRequestDestroyRepository(
 
304
    tests.TestCaseWithMemoryTransport):
 
305
    """Tests for BzrDir.destroy_repository."""
 
306
 
 
307
    def test_destroy_repository_default(self):
 
308
        """The repository can be removed."""
 
309
        backing = self.get_transport()
 
310
        dir = self.make_repository('.').bzrdir
 
311
        request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
 
312
        request = request_class(backing)
 
313
        expected = smart_req.SuccessfulSmartServerResponse(('ok',))
 
314
        self.assertEqual(expected, request.execute(''))
 
315
 
 
316
    def test_destroy_repository_missing(self):
 
317
        """An error is raised if the repository didn't exist."""
 
318
        backing = self.get_transport()
 
319
        dir = self.make_bzrdir('.')
 
320
        request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
 
321
        request = request_class(backing)
 
322
        expected = smart_req.FailedSmartServerResponse(
 
323
            ('norepository',), None)
 
324
        self.assertEqual(expected, request.execute(''))
 
325
 
 
326
 
196
327
class TestSmartServerRequestCreateRepository(tests.TestCaseWithMemoryTransport):
197
328
    """Tests for BzrDir.create_repository."""
198
329
 
200
331
        """When there is a bzrdir present, the call succeeds."""
201
332
        backing = self.get_transport()
202
333
        self.make_bzrdir('.')
203
 
        request_class = bzrlib.smart.bzrdir.SmartServerRequestCreateRepository
 
334
        request_class = smart_dir.SmartServerRequestCreateRepository
204
335
        request = request_class(backing)
205
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
336
        reference_bzrdir_format = controldir.format_registry.get('pack-0.92')()
206
337
        reference_format = reference_bzrdir_format.repository_format
207
338
        network_name = reference_format.network_name()
208
 
        expected = SuccessfulSmartServerResponse(
 
339
        expected = smart_req.SuccessfulSmartServerResponse(
209
340
            ('ok', 'no', 'no', 'no', network_name))
210
341
        self.assertEqual(expected, request.execute('', network_name, 'True'))
211
342
 
218
349
        backing = self.get_transport()
219
350
        request = self._request_class(backing)
220
351
        self.make_bzrdir('.')
221
 
        self.assertEqual(SmartServerResponse(('norepository', )),
 
352
        self.assertEqual(smart_req.SmartServerResponse(('norepository', )),
222
353
            request.execute(''))
223
354
 
224
355
    def test_nonshared_repository(self):
230
361
        result = self._make_repository_and_result()
231
362
        self.assertEqual(result, request.execute(''))
232
363
        self.make_bzrdir('subdir')
233
 
        self.assertEqual(SmartServerResponse(('norepository', )),
 
364
        self.assertEqual(smart_req.SmartServerResponse(('norepository', )),
234
365
            request.execute('subdir'))
235
366
 
236
367
    def _make_repository_and_result(self, shared=False, format=None):
247
378
            subtrees = 'yes'
248
379
        else:
249
380
            subtrees = 'no'
250
 
        if (smart.bzrdir.SmartServerRequestFindRepositoryV3 ==
 
381
        if repo._format.supports_external_lookups:
 
382
            external = 'yes'
 
383
        else:
 
384
            external = 'no'
 
385
        if (smart_dir.SmartServerRequestFindRepositoryV3 ==
251
386
            self._request_class):
252
 
            return SuccessfulSmartServerResponse(
253
 
                ('ok', '', rich_root, subtrees, 'no',
 
387
            return smart_req.SuccessfulSmartServerResponse(
 
388
                ('ok', '', rich_root, subtrees, external,
254
389
                 repo._format.network_name()))
255
 
        elif (smart.bzrdir.SmartServerRequestFindRepositoryV2 ==
 
390
        elif (smart_dir.SmartServerRequestFindRepositoryV2 ==
256
391
            self._request_class):
257
392
            # All tests so far are on formats, and for non-external
258
393
            # repositories.
259
 
            return SuccessfulSmartServerResponse(
260
 
                ('ok', '', rich_root, subtrees, 'no'))
 
394
            return smart_req.SuccessfulSmartServerResponse(
 
395
                ('ok', '', rich_root, subtrees, external))
261
396
        else:
262
 
            return SuccessfulSmartServerResponse(('ok', '', rich_root, subtrees))
 
397
            return smart_req.SuccessfulSmartServerResponse(
 
398
                ('ok', '', rich_root, subtrees))
263
399
 
264
400
    def test_shared_repository(self):
265
401
        """When there is a shared repository, we get 'ok', 'relpath-to-repo'."""
268
404
        result = self._make_repository_and_result(shared=True)
269
405
        self.assertEqual(result, request.execute(''))
270
406
        self.make_bzrdir('subdir')
271
 
        result2 = SmartServerResponse(result.args[0:1] + ('..', ) + result.args[2:])
 
407
        result2 = smart_req.SmartServerResponse(
 
408
            result.args[0:1] + ('..', ) + result.args[2:])
272
409
        self.assertEqual(result2,
273
410
            request.execute('subdir'))
274
411
        self.make_bzrdir('subdir/deeper')
275
 
        result3 = SmartServerResponse(result.args[0:1] + ('../..', ) + result.args[2:])
 
412
        result3 = smart_req.SmartServerResponse(
 
413
            result.args[0:1] + ('../..', ) + result.args[2:])
276
414
        self.assertEqual(result3,
277
415
            request.execute('subdir/deeper'))
278
416
 
280
418
        """Test for the format attributes for rich root and subtree support."""
281
419
        backing = self.get_transport()
282
420
        request = self._request_class(backing)
283
 
        result = self._make_repository_and_result(format='dirstate-with-subtree')
 
421
        result = self._make_repository_and_result(
 
422
            format='development-subtree')
284
423
        # check the test will be valid
285
424
        self.assertEqual('yes', result.args[2])
286
425
        self.assertEqual('yes', result.args[3])
290
429
        """Test for the supports_external_lookups attribute."""
291
430
        backing = self.get_transport()
292
431
        request = self._request_class(backing)
293
 
        result = self._make_repository_and_result(format='dirstate-with-subtree')
 
432
        result = self._make_repository_and_result(
 
433
            format='development-subtree')
294
434
        # check the test will be valid
295
 
        self.assertEqual('no', result.args[4])
 
435
        self.assertEqual('yes', result.args[4])
296
436
        self.assertEqual(result, request.execute(''))
297
437
 
298
438
 
307
447
        local_result = dir._get_config()._get_config_file().read()
308
448
        request_class = smart_dir.SmartServerBzrDirRequestConfigFile
309
449
        request = request_class(backing)
310
 
        expected = SuccessfulSmartServerResponse((), local_result)
 
450
        expected = smart_req.SuccessfulSmartServerResponse((), local_result)
311
451
        self.assertEqual(expected, request.execute(''))
312
452
 
313
453
    def test_missing(self):
315
455
        dir = self.make_bzrdir('.')
316
456
        request_class = smart_dir.SmartServerBzrDirRequestConfigFile
317
457
        request = request_class(backing)
318
 
        expected = SuccessfulSmartServerResponse((), '')
 
458
        expected = smart_req.SuccessfulSmartServerResponse((), '')
 
459
        self.assertEqual(expected, request.execute(''))
 
460
 
 
461
 
 
462
class TestSmartServerBzrDirRequestGetBranches(
 
463
    tests.TestCaseWithMemoryTransport):
 
464
    """Tests for BzrDir.get_branches."""
 
465
 
 
466
    def test_simple(self):
 
467
        backing = self.get_transport()
 
468
        branch = self.make_branch('.')
 
469
        request_class = smart_dir.SmartServerBzrDirRequestGetBranches
 
470
        request = request_class(backing)
 
471
        local_result = bencode.bencode(
 
472
            {"": ("branch", branch._format.network_name())})
 
473
        expected = smart_req.SuccessfulSmartServerResponse(
 
474
            ("success", ), local_result)
 
475
        self.assertEqual(expected, request.execute(''))
 
476
 
 
477
    def test_empty(self):
 
478
        backing = self.get_transport()
 
479
        dir = self.make_bzrdir('.')
 
480
        request_class = smart_dir.SmartServerBzrDirRequestGetBranches
 
481
        request = request_class(backing)
 
482
        local_result = bencode.bencode({})
 
483
        expected = smart_req.SuccessfulSmartServerResponse(
 
484
            ('success',), local_result)
319
485
        self.assertEqual(expected, request.execute(''))
320
486
 
321
487
 
324
490
    def test_empty_dir(self):
325
491
        """Initializing an empty dir should succeed and do it."""
326
492
        backing = self.get_transport()
327
 
        request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
328
 
        self.assertEqual(SmartServerResponse(('ok', )),
 
493
        request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
 
494
        self.assertEqual(smart_req.SmartServerResponse(('ok', )),
329
495
            request.execute(''))
330
 
        made_dir = bzrdir.BzrDir.open_from_transport(backing)
 
496
        made_dir = controldir.ControlDir.open_from_transport(backing)
331
497
        # no branch, tree or repository is expected with the current
332
498
        # default formart.
333
499
        self.assertRaises(errors.NoWorkingTree, made_dir.open_workingtree)
337
503
    def test_missing_dir(self):
338
504
        """Initializing a missing directory should fail like the bzrdir api."""
339
505
        backing = self.get_transport()
340
 
        request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
 
506
        request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
341
507
        self.assertRaises(errors.NoSuchFile,
342
508
            request.execute, 'subdir')
343
509
 
344
510
    def test_initialized_dir(self):
345
511
        """Initializing an extant bzrdir should fail like the bzrdir api."""
346
512
        backing = self.get_transport()
347
 
        request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
 
513
        request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
348
514
        self.make_bzrdir('subdir')
349
 
        self.assertRaises(errors.FileExists,
 
515
        self.assertRaises(errors.AlreadyControlDirError,
350
516
            request.execute, 'subdir')
351
517
 
352
518
 
353
 
class TestSmartServerRequestBzrDirInitializeEx(tests.TestCaseWithMemoryTransport):
 
519
class TestSmartServerRequestBzrDirInitializeEx(
 
520
    tests.TestCaseWithMemoryTransport):
354
521
    """Basic tests for BzrDir.initialize_ex_1.16 in the smart server.
355
522
 
356
523
    The main unit tests in test_bzrdir exercise the API comprehensively.
360
527
        """Initializing an empty dir should succeed and do it."""
361
528
        backing = self.get_transport()
362
529
        name = self.make_bzrdir('reference')._format.network_name()
363
 
        request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)
364
 
        self.assertEqual(SmartServerResponse(('', '', '', '', '', '', name,
365
 
            'False', '', '', '')),
 
530
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
 
531
        self.assertEqual(
 
532
            smart_req.SmartServerResponse(('', '', '', '', '', '', name,
 
533
                                           'False', '', '', '')),
366
534
            request.execute(name, '', 'True', 'False', 'False', '', '', '', '',
367
 
            'False'))
368
 
        made_dir = bzrdir.BzrDir.open_from_transport(backing)
 
535
                            'False'))
 
536
        made_dir = controldir.ControlDir.open_from_transport(backing)
369
537
        # no branch, tree or repository is expected with the current
370
538
        # default format.
371
539
        self.assertRaises(errors.NoWorkingTree, made_dir.open_workingtree)
376
544
        """Initializing a missing directory should fail like the bzrdir api."""
377
545
        backing = self.get_transport()
378
546
        name = self.make_bzrdir('reference')._format.network_name()
379
 
        request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)
 
547
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
380
548
        self.assertRaises(errors.NoSuchFile, request.execute, name,
381
549
            'subdir/dir', 'False', 'False', 'False', '', '', '', '', 'False')
382
550
 
384
552
        """Initializing an extant directory should fail like the bzrdir api."""
385
553
        backing = self.get_transport()
386
554
        name = self.make_bzrdir('reference')._format.network_name()
387
 
        request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)
 
555
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
388
556
        self.make_bzrdir('subdir')
389
557
        self.assertRaises(errors.FileExists, request.execute, name, 'subdir',
390
558
            'False', 'False', 'False', '', '', '', '', 'False')
391
559
 
392
560
 
 
561
class TestSmartServerRequestOpenBzrDir(tests.TestCaseWithMemoryTransport):
 
562
 
 
563
    def test_no_directory(self):
 
564
        backing = self.get_transport()
 
565
        request = smart_dir.SmartServerRequestOpenBzrDir(backing)
 
566
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
567
            request.execute('does-not-exist'))
 
568
 
 
569
    def test_empty_directory(self):
 
570
        backing = self.get_transport()
 
571
        backing.mkdir('empty')
 
572
        request = smart_dir.SmartServerRequestOpenBzrDir(backing)
 
573
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
574
            request.execute('empty'))
 
575
 
 
576
    def test_outside_root_client_path(self):
 
577
        backing = self.get_transport()
 
578
        request = smart_dir.SmartServerRequestOpenBzrDir(backing,
 
579
            root_client_path='root')
 
580
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
581
            request.execute('not-root'))
 
582
 
 
583
 
 
584
class TestSmartServerRequestOpenBzrDir_2_1(tests.TestCaseWithMemoryTransport):
 
585
 
 
586
    def test_no_directory(self):
 
587
        backing = self.get_transport()
 
588
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
 
589
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
590
            request.execute('does-not-exist'))
 
591
 
 
592
    def test_empty_directory(self):
 
593
        backing = self.get_transport()
 
594
        backing.mkdir('empty')
 
595
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
 
596
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
597
            request.execute('empty'))
 
598
 
 
599
    def test_present_without_workingtree(self):
 
600
        backing = self.get_transport()
 
601
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
 
602
        self.make_bzrdir('.')
 
603
        self.assertEqual(smart_req.SmartServerResponse(('yes', 'no')),
 
604
            request.execute(''))
 
605
 
 
606
    def test_outside_root_client_path(self):
 
607
        backing = self.get_transport()
 
608
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing,
 
609
            root_client_path='root')
 
610
        self.assertEqual(smart_req.SmartServerResponse(('no',)),
 
611
            request.execute('not-root'))
 
612
 
 
613
 
 
614
class TestSmartServerRequestOpenBzrDir_2_1_disk(TestCaseWithChrootedTransport):
 
615
 
 
616
    def test_present_with_workingtree(self):
 
617
        self.vfs_transport_factory = test_server.LocalURLServer
 
618
        backing = self.get_transport()
 
619
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
 
620
        bd = self.make_bzrdir('.')
 
621
        bd.create_repository()
 
622
        bd.create_branch()
 
623
        bd.create_workingtree()
 
624
        self.assertEqual(smart_req.SmartServerResponse(('yes', 'yes')),
 
625
            request.execute(''))
 
626
 
 
627
 
393
628
class TestSmartServerRequestOpenBranch(TestCaseWithChrootedTransport):
394
629
 
395
630
    def test_no_branch(self):
396
631
        """When there is no branch, ('nobranch', ) is returned."""
397
632
        backing = self.get_transport()
398
 
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
 
633
        request = smart_dir.SmartServerRequestOpenBranch(backing)
399
634
        self.make_bzrdir('.')
400
 
        self.assertEqual(SmartServerResponse(('nobranch', )),
 
635
        self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
401
636
            request.execute(''))
402
637
 
403
638
    def test_branch(self):
404
639
        """When there is a branch, 'ok' is returned."""
405
640
        backing = self.get_transport()
406
 
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
 
641
        request = smart_dir.SmartServerRequestOpenBranch(backing)
407
642
        self.make_branch('.')
408
 
        self.assertEqual(SmartServerResponse(('ok', '')),
 
643
        self.assertEqual(smart_req.SmartServerResponse(('ok', '')),
409
644
            request.execute(''))
410
645
 
411
646
    def test_branch_reference(self):
412
647
        """When there is a branch reference, the reference URL is returned."""
 
648
        self.vfs_transport_factory = test_server.LocalURLServer
413
649
        backing = self.get_transport()
414
 
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
 
650
        request = smart_dir.SmartServerRequestOpenBranch(backing)
415
651
        branch = self.make_branch('branch')
416
652
        checkout = branch.create_checkout('reference',lightweight=True)
417
 
        reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
 
653
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
 
654
            checkout.bzrdir)
418
655
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
419
 
        self.assertEqual(SmartServerResponse(('ok', reference_url)),
 
656
        self.assertEqual(smart_req.SmartServerResponse(('ok', reference_url)),
420
657
            request.execute('reference'))
421
658
 
 
659
    def test_notification_on_branch_from_repository(self):
 
660
        """When there is a repository, the error should return details."""
 
661
        backing = self.get_transport()
 
662
        request = smart_dir.SmartServerRequestOpenBranch(backing)
 
663
        repo = self.make_repository('.')
 
664
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
 
665
            request.execute(''))
 
666
 
422
667
 
423
668
class TestSmartServerRequestOpenBranchV2(TestCaseWithChrootedTransport):
424
669
 
426
671
        """When there is no branch, ('nobranch', ) is returned."""
427
672
        backing = self.get_transport()
428
673
        self.make_bzrdir('.')
429
 
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
430
 
        self.assertEqual(SmartServerResponse(('nobranch', )),
431
 
            request.execute(''))
432
 
 
433
 
    def test_branch(self):
434
 
        """When there is a branch, 'ok' is returned."""
435
 
        backing = self.get_transport()
436
 
        expected = self.make_branch('.')._format.network_name()
437
 
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
438
 
        self.assertEqual(SuccessfulSmartServerResponse(('branch', expected)),
439
 
            request.execute(''))
440
 
 
441
 
    def test_branch_reference(self):
442
 
        """When there is a branch reference, the reference URL is returned."""
443
 
        backing = self.get_transport()
444
 
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
445
 
        branch = self.make_branch('branch')
446
 
        checkout = branch.create_checkout('reference',lightweight=True)
447
 
        reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
448
 
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
449
 
        self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
450
 
            request.execute('reference'))
451
 
 
452
 
    def test_stacked_branch(self):
453
 
        """Opening a stacked branch does not open the stacked-on branch."""
454
 
        trunk = self.make_branch('trunk')
455
 
        feature = self.make_branch('feature', format='1.9')
456
 
        feature.set_stacked_on_url(trunk.base)
457
 
        opened_branches = []
458
 
        Branch.hooks.install_named_hook('open', opened_branches.append, None)
459
 
        backing = self.get_transport()
460
 
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
461
 
        request.setup_jail()
462
 
        try:
463
 
            response = request.execute('feature')
464
 
        finally:
465
 
            request.teardown_jail()
466
 
        expected_format = feature._format.network_name()
467
 
        self.assertEqual(
468
 
            SuccessfulSmartServerResponse(('branch', expected_format)),
469
 
            response)
470
 
        self.assertLength(1, opened_branches)
 
674
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
 
675
        self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
 
676
            request.execute(''))
 
677
 
 
678
    def test_branch(self):
 
679
        """When there is a branch, 'ok' is returned."""
 
680
        backing = self.get_transport()
 
681
        expected = self.make_branch('.')._format.network_name()
 
682
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
 
683
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
 
684
                ('branch', expected)),
 
685
                         request.execute(''))
 
686
 
 
687
    def test_branch_reference(self):
 
688
        """When there is a branch reference, the reference URL is returned."""
 
689
        self.vfs_transport_factory = test_server.LocalURLServer
 
690
        backing = self.get_transport()
 
691
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
 
692
        branch = self.make_branch('branch')
 
693
        checkout = branch.create_checkout('reference',lightweight=True)
 
694
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
 
695
            checkout.bzrdir)
 
696
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
 
697
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
 
698
                ('ref', reference_url)),
 
699
                         request.execute('reference'))
 
700
 
 
701
    def test_stacked_branch(self):
 
702
        """Opening a stacked branch does not open the stacked-on branch."""
 
703
        trunk = self.make_branch('trunk')
 
704
        feature = self.make_branch('feature')
 
705
        feature.set_stacked_on_url(trunk.base)
 
706
        opened_branches = []
 
707
        _mod_branch.Branch.hooks.install_named_hook(
 
708
            'open', opened_branches.append, None)
 
709
        backing = self.get_transport()
 
710
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
 
711
        request.setup_jail()
 
712
        try:
 
713
            response = request.execute('feature')
 
714
        finally:
 
715
            request.teardown_jail()
 
716
        expected_format = feature._format.network_name()
 
717
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
 
718
                ('branch', expected_format)),
 
719
                         response)
 
720
        self.assertLength(1, opened_branches)
 
721
 
 
722
    def test_notification_on_branch_from_repository(self):
 
723
        """When there is a repository, the error should return details."""
 
724
        backing = self.get_transport()
 
725
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
 
726
        repo = self.make_repository('.')
 
727
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
 
728
            request.execute(''))
 
729
 
 
730
 
 
731
class TestSmartServerRequestOpenBranchV3(TestCaseWithChrootedTransport):
 
732
 
 
733
    def test_no_branch(self):
 
734
        """When there is no branch, ('nobranch', ) is returned."""
 
735
        backing = self.get_transport()
 
736
        self.make_bzrdir('.')
 
737
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
 
738
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
 
739
            request.execute(''))
 
740
 
 
741
    def test_branch(self):
 
742
        """When there is a branch, 'ok' is returned."""
 
743
        backing = self.get_transport()
 
744
        expected = self.make_branch('.')._format.network_name()
 
745
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
 
746
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
 
747
                ('branch', expected)),
 
748
                         request.execute(''))
 
749
 
 
750
    def test_branch_reference(self):
 
751
        """When there is a branch reference, the reference URL is returned."""
 
752
        self.vfs_transport_factory = test_server.LocalURLServer
 
753
        backing = self.get_transport()
 
754
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
 
755
        branch = self.make_branch('branch')
 
756
        checkout = branch.create_checkout('reference',lightweight=True)
 
757
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
 
758
            checkout.bzrdir)
 
759
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
 
760
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
 
761
                ('ref', reference_url)),
 
762
                         request.execute('reference'))
 
763
 
 
764
    def test_stacked_branch(self):
 
765
        """Opening a stacked branch does not open the stacked-on branch."""
 
766
        trunk = self.make_branch('trunk')
 
767
        feature = self.make_branch('feature')
 
768
        feature.set_stacked_on_url(trunk.base)
 
769
        opened_branches = []
 
770
        _mod_branch.Branch.hooks.install_named_hook(
 
771
            'open', opened_branches.append, None)
 
772
        backing = self.get_transport()
 
773
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
 
774
        request.setup_jail()
 
775
        try:
 
776
            response = request.execute('feature')
 
777
        finally:
 
778
            request.teardown_jail()
 
779
        expected_format = feature._format.network_name()
 
780
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
 
781
                ('branch', expected_format)),
 
782
                         response)
 
783
        self.assertLength(1, opened_branches)
 
784
 
 
785
    def test_notification_on_branch_from_repository(self):
 
786
        """When there is a repository, the error should return details."""
 
787
        backing = self.get_transport()
 
788
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
 
789
        repo = self.make_repository('.')
 
790
        self.assertEqual(smart_req.SmartServerResponse(
 
791
                ('nobranch', 'location is a repository')),
 
792
                         request.execute(''))
471
793
 
472
794
 
473
795
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
475
797
    def test_empty(self):
476
798
        """For an empty branch, the body is empty."""
477
799
        backing = self.get_transport()
478
 
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
 
800
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
479
801
        self.make_branch('.')
480
 
        self.assertEqual(SmartServerResponse(('ok', ), ''),
 
802
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), ''),
481
803
            request.execute(''))
482
804
 
483
805
    def test_not_empty(self):
484
806
        """For a non-empty branch, the body is empty."""
485
807
        backing = self.get_transport()
486
 
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
 
808
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
487
809
        tree = self.make_branch_and_memory_tree('.')
488
810
        tree.lock_write()
489
811
        tree.add('')
491
813
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
492
814
        tree.unlock()
493
815
        self.assertEqual(
494
 
            SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
 
816
            smart_req.SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
495
817
            request.execute(''))
496
818
 
497
819
 
500
822
    def test_no_branch(self):
501
823
        """When there is a bzrdir and no branch, NotBranchError is raised."""
502
824
        backing = self.get_transport()
503
 
        request = smart.branch.SmartServerBranchRequest(backing)
 
825
        request = smart_branch.SmartServerBranchRequest(backing)
504
826
        self.make_bzrdir('.')
505
827
        self.assertRaises(errors.NotBranchError,
506
828
            request.execute, '')
508
830
    def test_branch_reference(self):
509
831
        """When there is a branch reference, NotBranchError is raised."""
510
832
        backing = self.get_transport()
511
 
        request = smart.branch.SmartServerBranchRequest(backing)
 
833
        request = smart_branch.SmartServerBranchRequest(backing)
512
834
        branch = self.make_branch('branch')
513
835
        checkout = branch.create_checkout('reference',lightweight=True)
514
836
        self.assertRaises(errors.NotBranchError,
515
837
            request.execute, 'checkout')
516
838
 
517
839
 
518
 
class TestSmartServerBranchRequestLastRevisionInfo(tests.TestCaseWithMemoryTransport):
 
840
class TestSmartServerBranchRequestLastRevisionInfo(
 
841
    tests.TestCaseWithMemoryTransport):
519
842
 
520
843
    def test_empty(self):
521
844
        """For an empty branch, the result is ('ok', '0', 'null:')."""
522
845
        backing = self.get_transport()
523
 
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
846
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
524
847
        self.make_branch('.')
525
 
        self.assertEqual(SmartServerResponse(('ok', '0', 'null:')),
 
848
        self.assertEqual(smart_req.SmartServerResponse(('ok', '0', 'null:')),
526
849
            request.execute(''))
527
850
 
528
851
    def test_not_empty(self):
529
852
        """For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
530
853
        backing = self.get_transport()
531
 
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
854
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
532
855
        tree = self.make_branch_and_memory_tree('.')
533
856
        tree.lock_write()
534
857
        tree.add('')
537
860
        r2 = tree.commit('2nd commit', rev_id=rev_id_utf8)
538
861
        tree.unlock()
539
862
        self.assertEqual(
540
 
            SmartServerResponse(('ok', '2', rev_id_utf8)),
 
863
            smart_req.SmartServerResponse(('ok', '2', rev_id_utf8)),
541
864
            request.execute(''))
542
865
 
543
866
 
544
 
class TestSmartServerBranchRequestGetConfigFile(tests.TestCaseWithMemoryTransport):
 
867
class TestSmartServerBranchRequestRevisionIdToRevno(
 
868
    tests.TestCaseWithMemoryTransport):
 
869
 
 
870
    def test_null(self):
 
871
        backing = self.get_transport()
 
872
        request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
 
873
            backing)
 
874
        self.make_branch('.')
 
875
        self.assertEqual(smart_req.SmartServerResponse(('ok', '0')),
 
876
            request.execute('', 'null:'))
 
877
 
 
878
    def test_simple(self):
 
879
        backing = self.get_transport()
 
880
        request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
 
881
            backing)
 
882
        tree = self.make_branch_and_memory_tree('.')
 
883
        tree.lock_write()
 
884
        tree.add('')
 
885
        r1 = tree.commit('1st commit')
 
886
        tree.unlock()
 
887
        self.assertEqual(
 
888
            smart_req.SmartServerResponse(('ok', '1')),
 
889
            request.execute('', r1))
 
890
 
 
891
    def test_not_found(self):
 
892
        backing = self.get_transport()
 
893
        request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
 
894
            backing)
 
895
        branch = self.make_branch('.')
 
896
        self.assertEqual(
 
897
            smart_req.FailedSmartServerResponse(
 
898
                ('NoSuchRevision', 'idontexist')),
 
899
            request.execute('', 'idontexist'))
 
900
 
 
901
 
 
902
class TestSmartServerBranchRequestGetConfigFile(
 
903
    tests.TestCaseWithMemoryTransport):
545
904
 
546
905
    def test_default(self):
547
906
        """With no file, we get empty content."""
548
907
        backing = self.get_transport()
549
 
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
 
908
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
550
909
        branch = self.make_branch('.')
551
910
        # there should be no file by default
552
911
        content = ''
553
 
        self.assertEqual(SmartServerResponse(('ok', ), content),
 
912
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), content),
554
913
            request.execute(''))
555
914
 
556
915
    def test_with_content(self):
558
917
        # branch.control_files.get('branch.conf') for now - in the future it may
559
918
        # perform more complex processing.
560
919
        backing = self.get_transport()
561
 
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
 
920
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
562
921
        branch = self.make_branch('.')
563
922
        branch._transport.put_bytes('branch.conf', 'foo bar baz')
564
 
        self.assertEqual(SmartServerResponse(('ok', ), 'foo bar baz'),
 
923
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'foo bar baz'),
565
924
            request.execute(''))
566
925
 
567
926
 
568
927
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
569
928
 
570
929
    def get_lock_tokens(self, branch):
571
 
        branch_token = branch.lock_write()
572
 
        repo_token = branch.repository.lock_write()
 
930
        branch_token = branch.lock_write().branch_token
 
931
        repo_token = branch.repository.lock_write().repository_token
573
932
        branch.repository.unlock()
574
933
        return branch_token, repo_token
575
934
 
576
935
 
 
936
class TestSmartServerBranchRequestPutConfigFile(TestLockedBranch):
 
937
 
 
938
    def test_with_content(self):
 
939
        backing = self.get_transport()
 
940
        request = smart_branch.SmartServerBranchPutConfigFile(backing)
 
941
        branch = self.make_branch('.')
 
942
        branch_token, repo_token = self.get_lock_tokens(branch)
 
943
        self.assertIs(None, request.execute('', branch_token, repo_token))
 
944
        self.assertEqual(
 
945
            smart_req.SmartServerResponse(('ok', )),
 
946
            request.do_body('foo bar baz'))
 
947
        self.assertEqual(
 
948
            branch.control_transport.get_bytes('branch.conf'),
 
949
            'foo bar baz')
 
950
        branch.unlock()
 
951
 
 
952
 
577
953
class TestSmartServerBranchRequestSetConfigOption(TestLockedBranch):
578
954
 
579
955
    def test_value_name(self):
580
956
        branch = self.make_branch('.')
581
 
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
 
957
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
582
958
            branch.bzrdir.root_transport)
583
959
        branch_token, repo_token = self.get_lock_tokens(branch)
584
960
        config = branch._get_config()
585
961
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
586
962
            '')
587
 
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
 
963
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
588
964
        self.assertEqual('bar', config.get_option('foo'))
589
965
        # Cleanup
590
966
        branch.unlock()
591
967
 
592
968
    def test_value_name_section(self):
593
969
        branch = self.make_branch('.')
594
 
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
 
970
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
595
971
            branch.bzrdir.root_transport)
596
972
        branch_token, repo_token = self.get_lock_tokens(branch)
597
973
        config = branch._get_config()
598
974
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
599
975
            'gam')
600
 
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
 
976
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
601
977
        self.assertEqual('bar', config.get_option('foo', 'gam'))
602
978
        # Cleanup
603
979
        branch.unlock()
604
980
 
605
981
 
 
982
class TestSmartServerBranchRequestSetConfigOptionDict(TestLockedBranch):
 
983
 
 
984
    def setUp(self):
 
985
        TestLockedBranch.setUp(self)
 
986
        # A dict with non-ascii keys and values to exercise unicode
 
987
        # roundtripping.
 
988
        self.encoded_value_dict = (
 
989
            'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde')
 
990
        self.value_dict = {
 
991
            'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
 
992
 
 
993
    def test_value_name(self):
 
994
        branch = self.make_branch('.')
 
995
        request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
 
996
            branch.bzrdir.root_transport)
 
997
        branch_token, repo_token = self.get_lock_tokens(branch)
 
998
        config = branch._get_config()
 
999
        result = request.execute('', branch_token, repo_token,
 
1000
            self.encoded_value_dict, 'foo', '')
 
1001
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
1002
        self.assertEqual(self.value_dict, config.get_option('foo'))
 
1003
        # Cleanup
 
1004
        branch.unlock()
 
1005
 
 
1006
    def test_value_name_section(self):
 
1007
        branch = self.make_branch('.')
 
1008
        request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
 
1009
            branch.bzrdir.root_transport)
 
1010
        branch_token, repo_token = self.get_lock_tokens(branch)
 
1011
        config = branch._get_config()
 
1012
        result = request.execute('', branch_token, repo_token,
 
1013
            self.encoded_value_dict, 'foo', 'gam')
 
1014
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
1015
        self.assertEqual(self.value_dict, config.get_option('foo', 'gam'))
 
1016
        # Cleanup
 
1017
        branch.unlock()
 
1018
 
 
1019
 
606
1020
class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):
607
1021
    # Only called when the branch format and tags match [yay factory
608
1022
    # methods] so only need to test straight forward cases.
612
1026
        tag_bytes = base_branch._get_tags_bytes()
613
1027
        # get_lock_tokens takes out a lock.
614
1028
        branch_token, repo_token = self.get_lock_tokens(base_branch)
615
 
        request = smart.branch.SmartServerBranchSetTagsBytes(
 
1029
        request = smart_branch.SmartServerBranchSetTagsBytes(
616
1030
            self.get_transport())
617
1031
        response = request.execute('base', branch_token, repo_token)
618
1032
        self.assertEqual(None, response)
619
1033
        response = request.do_chunk(tag_bytes)
620
1034
        self.assertEqual(None, response)
621
1035
        response = request.do_end()
622
 
        self.assertEquals(
623
 
            SuccessfulSmartServerResponse(()), response)
 
1036
        self.assertEqual(
 
1037
            smart_req.SuccessfulSmartServerResponse(()), response)
624
1038
        base_branch.unlock()
625
1039
 
626
1040
    def test_lock_failed(self):
627
1041
        base_branch = self.make_branch('base')
628
1042
        base_branch.lock_write()
629
1043
        tag_bytes = base_branch._get_tags_bytes()
630
 
        request = smart.branch.SmartServerBranchSetTagsBytes(
 
1044
        request = smart_branch.SmartServerBranchSetTagsBytes(
631
1045
            self.get_transport())
632
1046
        self.assertRaises(errors.TokenMismatch, request.execute,
633
1047
            'base', 'wrong token', 'wrong token')
644
1058
    """Base test case for verbs that implement set_last_revision."""
645
1059
 
646
1060
    def setUp(self):
647
 
        tests.TestCaseWithMemoryTransport.setUp(self)
 
1061
        super(SetLastRevisionTestBase, self).setUp()
648
1062
        backing_transport = self.get_transport()
649
1063
        self.request = self.request_class(backing_transport)
650
1064
        self.tree = self.make_branch_and_memory_tree('.')
664
1078
 
665
1079
    def assertRequestSucceeds(self, revision_id, revno):
666
1080
        response = self.set_last_revision(revision_id, revno)
667
 
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)), response)
 
1081
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1082
                         response)
668
1083
 
669
1084
 
670
1085
class TestSetLastRevisionVerbMixin(object):
678
1093
        """If the revision_id is not present, the verb returns NoSuchRevision.
679
1094
        """
680
1095
        revision_id = 'non-existent revision'
681
 
        self.assertEqual(
682
 
            FailedSmartServerResponse(('NoSuchRevision', revision_id)),
683
 
            self.set_last_revision(revision_id, 1))
 
1096
        self.assertEqual(smart_req.FailedSmartServerResponse(('NoSuchRevision',
 
1097
                                                              revision_id)),
 
1098
                         self.set_last_revision(revision_id, 1))
684
1099
 
685
1100
    def make_tree_with_two_commits(self):
686
1101
        self.tree.lock_write()
698
1113
        # its repository.
699
1114
        self.make_tree_with_two_commits()
700
1115
        rev_id_utf8 = u'\xc8'.encode('utf-8')
701
 
        self.tree.branch.set_revision_history([])
 
1116
        self.tree.branch.set_last_revision_info(0, 'null:')
702
1117
        self.assertEqual(
703
1118
            (0, 'null:'), self.tree.branch.last_revision_info())
704
1119
        # We can update the branch to a revision that is present in the
726
1141
        rejection_message = u'rejection message\N{INTERROBANG}'
727
1142
        def hook_that_rejects(params):
728
1143
            raise errors.TipChangeRejected(rejection_message)
729
 
        Branch.hooks.install_named_hook(
 
1144
        _mod_branch.Branch.hooks.install_named_hook(
730
1145
            'pre_change_branch_tip', hook_that_rejects, None)
731
1146
        self.assertEqual(
732
 
            FailedSmartServerResponse(
 
1147
            smart_req.FailedSmartServerResponse(
733
1148
                ('TipChangeRejected', rejection_message.encode('utf-8'))),
734
1149
            self.set_last_revision('null:', 0))
735
1150
 
738
1153
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
739
1154
    """Tests for Branch.set_last_revision verb."""
740
1155
 
741
 
    request_class = smart.branch.SmartServerBranchRequestSetLastRevision
 
1156
    request_class = smart_branch.SmartServerBranchRequestSetLastRevision
742
1157
 
743
1158
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
744
1159
        return self.request.execute(
749
1164
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
750
1165
    """Tests for Branch.set_last_revision_info verb."""
751
1166
 
752
 
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionInfo
 
1167
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionInfo
753
1168
 
754
1169
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
755
1170
        return self.request.execute(
766
1181
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
767
1182
    """Tests for Branch.set_last_revision_ex verb."""
768
1183
 
769
 
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionEx
 
1184
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionEx
770
1185
 
771
1186
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
772
1187
        return self.request.execute(
775
1190
    def assertRequestSucceeds(self, revision_id, revno):
776
1191
        response = self.set_last_revision(revision_id, revno)
777
1192
        self.assertEqual(
778
 
            SuccessfulSmartServerResponse(('ok', revno, revision_id)),
 
1193
            smart_req.SuccessfulSmartServerResponse(('ok', revno, revision_id)),
779
1194
            response)
780
1195
 
781
1196
    def test_branch_last_revision_info_rewind(self):
792
1207
        response = self.request.execute(
793
1208
            '', branch_token, repo_token, rev_id_utf8, 0, 0)
794
1209
        self.assertEqual(
795
 
            SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
 
1210
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
796
1211
            response)
797
1212
        self.assertEqual(
798
1213
            (2, 'rev-2'), self.tree.branch.last_revision_info())
802
1217
        response = self.request.execute(
803
1218
            '', branch_token, repo_token, rev_id_utf8, 0, 1)
804
1219
        self.assertEqual(
805
 
            SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
 
1220
            smart_req.SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
806
1221
            response)
807
1222
        self.unlock_branch()
808
1223
        self.assertEqual(
833
1248
        """
834
1249
        self.make_branch_with_divergent_history()
835
1250
        self.assertEqual(
836
 
            FailedSmartServerResponse(('Diverged',)),
 
1251
            smart_req.FailedSmartServerResponse(('Diverged',)),
837
1252
            self.set_last_revision('child-1', 2))
838
1253
        # The branch tip was not changed.
839
1254
        self.assertEqual('child-2', self.tree.branch.last_revision())
847
1262
        response = self.request.execute(
848
1263
            '', branch_token, repo_token, 'child-1', 1, 0)
849
1264
        self.assertEqual(
850
 
            SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
 
1265
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
851
1266
            response)
852
1267
        self.unlock_branch()
853
1268
        # The branch tip was changed.
854
1269
        self.assertEqual('child-1', self.tree.branch.last_revision())
855
1270
 
856
1271
 
 
1272
class TestSmartServerBranchBreakLock(tests.TestCaseWithMemoryTransport):
 
1273
 
 
1274
    def test_lock_to_break(self):
 
1275
        base_branch = self.make_branch('base')
 
1276
        request = smart_branch.SmartServerBranchBreakLock(
 
1277
            self.get_transport())
 
1278
        base_branch.lock_write()
 
1279
        self.assertEqual(
 
1280
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1281
            request.execute('base'))
 
1282
 
 
1283
    def test_nothing_to_break(self):
 
1284
        base_branch = self.make_branch('base')
 
1285
        request = smart_branch.SmartServerBranchBreakLock(
 
1286
            self.get_transport())
 
1287
        self.assertEqual(
 
1288
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1289
            request.execute('base'))
 
1290
 
 
1291
 
857
1292
class TestSmartServerBranchRequestGetParent(tests.TestCaseWithMemoryTransport):
858
1293
 
859
1294
    def test_get_parent_none(self):
860
1295
        base_branch = self.make_branch('base')
861
 
        request = smart.branch.SmartServerBranchGetParent(self.get_transport())
 
1296
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
862
1297
        response = request.execute('base')
863
 
        self.assertEquals(
864
 
            SuccessfulSmartServerResponse(('',)), response)
 
1298
        self.assertEqual(
 
1299
            smart_req.SuccessfulSmartServerResponse(('',)), response)
865
1300
 
866
1301
    def test_get_parent_something(self):
867
1302
        base_branch = self.make_branch('base')
868
1303
        base_branch.set_parent(self.get_url('foo'))
869
 
        request = smart.branch.SmartServerBranchGetParent(self.get_transport())
 
1304
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
870
1305
        response = request.execute('base')
871
 
        self.assertEquals(
872
 
            SuccessfulSmartServerResponse(("../foo",)),
 
1306
        self.assertEqual(
 
1307
            smart_req.SuccessfulSmartServerResponse(("../foo",)),
873
1308
            response)
874
1309
 
875
1310
 
876
 
class TestSmartServerBranchRequestSetParent(tests.TestCaseWithMemoryTransport):
 
1311
class TestSmartServerBranchRequestSetParent(TestLockedBranch):
877
1312
 
878
1313
    def test_set_parent_none(self):
879
1314
        branch = self.make_branch('base', format="1.9")
880
1315
        branch.lock_write()
881
1316
        branch._set_parent_location('foo')
882
1317
        branch.unlock()
883
 
        request = smart.branch.SmartServerBranchRequestSetParentLocation(
 
1318
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
884
1319
            self.get_transport())
885
 
        branch_token = branch.lock_write()
886
 
        repo_token = branch.repository.lock_write()
 
1320
        branch_token, repo_token = self.get_lock_tokens(branch)
887
1321
        try:
888
1322
            response = request.execute('base', branch_token, repo_token, '')
889
1323
        finally:
890
 
            branch.repository.unlock()
891
1324
            branch.unlock()
892
 
        self.assertEqual(SuccessfulSmartServerResponse(()), response)
 
1325
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
 
1326
        # Refresh branch as SetParentLocation modified it
 
1327
        branch = branch.bzrdir.open_branch()
893
1328
        self.assertEqual(None, branch.get_parent())
894
1329
 
895
1330
    def test_set_parent_something(self):
896
1331
        branch = self.make_branch('base', format="1.9")
897
 
        request = smart.branch.SmartServerBranchRequestSetParentLocation(
 
1332
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
898
1333
            self.get_transport())
899
 
        branch_token = branch.lock_write()
900
 
        repo_token = branch.repository.lock_write()
 
1334
        branch_token, repo_token = self.get_lock_tokens(branch)
901
1335
        try:
902
1336
            response = request.execute('base', branch_token, repo_token,
903
 
            'http://bar/')
 
1337
                                       'http://bar/')
904
1338
        finally:
905
 
            branch.repository.unlock()
906
1339
            branch.unlock()
907
 
        self.assertEqual(SuccessfulSmartServerResponse(()), response)
908
 
        self.assertEqual('http://bar/', branch.get_parent())
909
 
 
910
 
 
911
 
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
 
1340
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
 
1341
        refreshed = _mod_branch.Branch.open(branch.base)
 
1342
        self.assertEqual('http://bar/', refreshed.get_parent())
 
1343
 
 
1344
 
 
1345
class TestSmartServerBranchRequestGetTagsBytes(
 
1346
    tests.TestCaseWithMemoryTransport):
912
1347
    # Only called when the branch format and tags match [yay factory
913
1348
    # methods] so only need to test straight forward cases.
914
1349
 
915
1350
    def test_get_bytes(self):
916
1351
        base_branch = self.make_branch('base')
917
 
        request = smart.branch.SmartServerBranchGetTagsBytes(
 
1352
        request = smart_branch.SmartServerBranchGetTagsBytes(
918
1353
            self.get_transport())
919
1354
        response = request.execute('base')
920
 
        self.assertEquals(
921
 
            SuccessfulSmartServerResponse(('',)), response)
 
1355
        self.assertEqual(
 
1356
            smart_req.SuccessfulSmartServerResponse(('',)), response)
922
1357
 
923
1358
 
924
1359
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
928
1363
        stacked_branch = self.make_branch('stacked', format='1.6')
929
1364
        # typically should be relative
930
1365
        stacked_branch.set_stacked_on_url('../base')
931
 
        request = smart.branch.SmartServerBranchRequestGetStackedOnURL(
 
1366
        request = smart_branch.SmartServerBranchRequestGetStackedOnURL(
932
1367
            self.get_transport())
933
1368
        response = request.execute('stacked')
934
 
        self.assertEquals(
935
 
            SmartServerResponse(('ok', '../base')),
 
1369
        self.assertEqual(
 
1370
            smart_req.SmartServerResponse(('ok', '../base')),
936
1371
            response)
937
1372
 
938
1373
 
939
 
class TestSmartServerBranchRequestLockWrite(tests.TestCaseWithMemoryTransport):
940
 
 
941
 
    def setUp(self):
942
 
        tests.TestCaseWithMemoryTransport.setUp(self)
 
1374
class TestSmartServerBranchRequestLockWrite(TestLockedBranch):
943
1375
 
944
1376
    def test_lock_write_on_unlocked_branch(self):
945
1377
        backing = self.get_transport()
946
 
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
 
1378
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
947
1379
        branch = self.make_branch('.', format='knit')
948
1380
        repository = branch.repository
949
1381
        response = request.execute('')
950
1382
        branch_nonce = branch.control_files._lock.peek().get('nonce')
951
1383
        repository_nonce = repository.control_files._lock.peek().get('nonce')
952
 
        self.assertEqual(
953
 
            SmartServerResponse(('ok', branch_nonce, repository_nonce)),
954
 
            response)
 
1384
        self.assertEqual(smart_req.SmartServerResponse(
 
1385
                ('ok', branch_nonce, repository_nonce)),
 
1386
                         response)
955
1387
        # The branch (and associated repository) is now locked.  Verify that
956
1388
        # with a new branch object.
957
1389
        new_branch = repository.bzrdir.open_branch()
958
1390
        self.assertRaises(errors.LockContention, new_branch.lock_write)
959
1391
        # Cleanup
960
 
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
 
1392
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
961
1393
        response = request.execute('', branch_nonce, repository_nonce)
962
1394
 
963
1395
    def test_lock_write_on_locked_branch(self):
964
1396
        backing = self.get_transport()
965
 
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
 
1397
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
966
1398
        branch = self.make_branch('.')
967
 
        branch_token = branch.lock_write()
 
1399
        branch_token = branch.lock_write().branch_token
968
1400
        branch.leave_lock_in_place()
969
1401
        branch.unlock()
970
1402
        response = request.execute('')
971
1403
        self.assertEqual(
972
 
            SmartServerResponse(('LockContention',)), response)
 
1404
            smart_req.SmartServerResponse(('LockContention',)), response)
973
1405
        # Cleanup
974
1406
        branch.lock_write(branch_token)
975
1407
        branch.dont_leave_lock_in_place()
977
1409
 
978
1410
    def test_lock_write_with_tokens_on_locked_branch(self):
979
1411
        backing = self.get_transport()
980
 
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
 
1412
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
981
1413
        branch = self.make_branch('.', format='knit')
982
 
        branch_token = branch.lock_write()
983
 
        repo_token = branch.repository.lock_write()
984
 
        branch.repository.unlock()
 
1414
        branch_token, repo_token = self.get_lock_tokens(branch)
985
1415
        branch.leave_lock_in_place()
986
1416
        branch.repository.leave_lock_in_place()
987
1417
        branch.unlock()
988
1418
        response = request.execute('',
989
1419
                                   branch_token, repo_token)
990
1420
        self.assertEqual(
991
 
            SmartServerResponse(('ok', branch_token, repo_token)), response)
 
1421
            smart_req.SmartServerResponse(('ok', branch_token, repo_token)),
 
1422
            response)
992
1423
        # Cleanup
993
1424
        branch.repository.lock_write(repo_token)
994
1425
        branch.repository.dont_leave_lock_in_place()
999
1430
 
1000
1431
    def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
1001
1432
        backing = self.get_transport()
1002
 
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
 
1433
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1003
1434
        branch = self.make_branch('.', format='knit')
1004
 
        branch_token = branch.lock_write()
1005
 
        repo_token = branch.repository.lock_write()
1006
 
        branch.repository.unlock()
 
1435
        branch_token, repo_token = self.get_lock_tokens(branch)
1007
1436
        branch.leave_lock_in_place()
1008
1437
        branch.repository.leave_lock_in_place()
1009
1438
        branch.unlock()
1010
1439
        response = request.execute('',
1011
1440
                                   branch_token+'xxx', repo_token)
1012
1441
        self.assertEqual(
1013
 
            SmartServerResponse(('TokenMismatch',)), response)
 
1442
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
1014
1443
        # Cleanup
1015
1444
        branch.repository.lock_write(repo_token)
1016
1445
        branch.repository.dont_leave_lock_in_place()
1021
1450
 
1022
1451
    def test_lock_write_on_locked_repo(self):
1023
1452
        backing = self.get_transport()
1024
 
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
 
1453
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1025
1454
        branch = self.make_branch('.', format='knit')
1026
1455
        repo = branch.repository
1027
 
        repo_token = repo.lock_write()
 
1456
        repo_token = repo.lock_write().repository_token
1028
1457
        repo.leave_lock_in_place()
1029
1458
        repo.unlock()
1030
1459
        response = request.execute('')
1031
1460
        self.assertEqual(
1032
 
            SmartServerResponse(('LockContention',)), response)
 
1461
            smart_req.SmartServerResponse(('LockContention',)), response)
1033
1462
        # Cleanup
1034
1463
        repo.lock_write(repo_token)
1035
1464
        repo.dont_leave_lock_in_place()
1037
1466
 
1038
1467
    def test_lock_write_on_readonly_transport(self):
1039
1468
        backing = self.get_readonly_transport()
1040
 
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
 
1469
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1041
1470
        branch = self.make_branch('.')
1042
1471
        root = self.get_transport().clone('/')
1043
1472
        path = urlutils.relative_url(root.base, self.get_transport().base)
1047
1476
        self.assertEqual('LockFailed', error_name)
1048
1477
 
1049
1478
 
1050
 
class TestSmartServerBranchRequestUnlock(tests.TestCaseWithMemoryTransport):
1051
 
 
1052
 
    def setUp(self):
1053
 
        tests.TestCaseWithMemoryTransport.setUp(self)
 
1479
class TestSmartServerBranchRequestGetPhysicalLockStatus(TestLockedBranch):
 
1480
 
 
1481
    def test_true(self):
 
1482
        backing = self.get_transport()
 
1483
        request = smart_branch.SmartServerBranchRequestGetPhysicalLockStatus(
 
1484
            backing)
 
1485
        branch = self.make_branch('.')
 
1486
        branch_token, repo_token = self.get_lock_tokens(branch)
 
1487
        self.assertEqual(True, branch.get_physical_lock_status())
 
1488
        response = request.execute('')
 
1489
        self.assertEqual(
 
1490
            smart_req.SmartServerResponse(('yes',)), response)
 
1491
        branch.unlock()
 
1492
 
 
1493
    def test_false(self):
 
1494
        backing = self.get_transport()
 
1495
        request = smart_branch.SmartServerBranchRequestGetPhysicalLockStatus(
 
1496
            backing)
 
1497
        branch = self.make_branch('.')
 
1498
        self.assertEqual(False, branch.get_physical_lock_status())
 
1499
        response = request.execute('')
 
1500
        self.assertEqual(
 
1501
            smart_req.SmartServerResponse(('no',)), response)
 
1502
 
 
1503
 
 
1504
class TestSmartServerBranchRequestUnlock(TestLockedBranch):
1054
1505
 
1055
1506
    def test_unlock_on_locked_branch_and_repo(self):
1056
1507
        backing = self.get_transport()
1057
 
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
 
1508
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
1058
1509
        branch = self.make_branch('.', format='knit')
1059
1510
        # Lock the branch
1060
 
        branch_token = branch.lock_write()
1061
 
        repo_token = branch.repository.lock_write()
1062
 
        branch.repository.unlock()
 
1511
        branch_token, repo_token = self.get_lock_tokens(branch)
1063
1512
        # Unlock the branch (and repo) object, leaving the physical locks
1064
1513
        # in place.
1065
1514
        branch.leave_lock_in_place()
1068
1517
        response = request.execute('',
1069
1518
                                   branch_token, repo_token)
1070
1519
        self.assertEqual(
1071
 
            SmartServerResponse(('ok',)), response)
 
1520
            smart_req.SmartServerResponse(('ok',)), response)
1072
1521
        # The branch is now unlocked.  Verify that with a new branch
1073
1522
        # object.
1074
1523
        new_branch = branch.bzrdir.open_branch()
1077
1526
 
1078
1527
    def test_unlock_on_unlocked_branch_unlocked_repo(self):
1079
1528
        backing = self.get_transport()
1080
 
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
 
1529
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
1081
1530
        branch = self.make_branch('.', format='knit')
1082
1531
        response = request.execute(
1083
1532
            '', 'branch token', 'repo token')
1084
1533
        self.assertEqual(
1085
 
            SmartServerResponse(('TokenMismatch',)), response)
 
1534
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
1086
1535
 
1087
1536
    def test_unlock_on_unlocked_branch_locked_repo(self):
1088
1537
        backing = self.get_transport()
1089
 
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
 
1538
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
1090
1539
        branch = self.make_branch('.', format='knit')
1091
1540
        # Lock the repository.
1092
 
        repo_token = branch.repository.lock_write()
 
1541
        repo_token = branch.repository.lock_write().repository_token
1093
1542
        branch.repository.leave_lock_in_place()
1094
1543
        branch.repository.unlock()
1095
1544
        # Issue branch lock_write request on the unlocked branch (with locked
1096
1545
        # repo).
1097
 
        response = request.execute(
1098
 
            '', 'branch token', repo_token)
 
1546
        response = request.execute('', 'branch token', repo_token)
1099
1547
        self.assertEqual(
1100
 
            SmartServerResponse(('TokenMismatch',)), response)
 
1548
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
1101
1549
        # Cleanup
1102
1550
        branch.repository.lock_write(repo_token)
1103
1551
        branch.repository.dont_leave_lock_in_place()
1113
1561
        # its the exact path being looked at and the server is not
1114
1562
        # searching.
1115
1563
        backing = self.get_transport()
1116
 
        request = smart.repository.SmartServerRepositoryRequest(backing)
 
1564
        request = smart_repo.SmartServerRepositoryRequest(backing)
1117
1565
        self.make_repository('.', shared=True)
1118
1566
        self.make_bzrdir('subdir')
1119
1567
        self.assertRaises(errors.NoRepositoryPresent,
1120
1568
            request.execute, 'subdir')
1121
1569
 
1122
1570
 
 
1571
class TestSmartServerRepositoryAddSignatureText(tests.TestCaseWithMemoryTransport):
 
1572
 
 
1573
    def test_add_text(self):
 
1574
        backing = self.get_transport()
 
1575
        request = smart_repo.SmartServerRepositoryAddSignatureText(backing)
 
1576
        tree = self.make_branch_and_memory_tree('.')
 
1577
        write_token = tree.lock_write()
 
1578
        self.addCleanup(tree.unlock)
 
1579
        tree.add('')
 
1580
        tree.commit("Message", rev_id='rev1')
 
1581
        tree.branch.repository.start_write_group()
 
1582
        write_group_tokens = tree.branch.repository.suspend_write_group()
 
1583
        self.assertEqual(None, request.execute('', write_token,
 
1584
            'rev1', *write_group_tokens))
 
1585
        response = request.do_body('somesignature')
 
1586
        self.assertTrue(response.is_successful())
 
1587
        self.assertEqual(response.args[0], 'ok')
 
1588
        write_group_tokens = response.args[1:]
 
1589
        tree.branch.repository.resume_write_group(write_group_tokens)
 
1590
        tree.branch.repository.commit_write_group()
 
1591
        tree.unlock()
 
1592
        self.assertEqual("somesignature",
 
1593
            tree.branch.repository.get_signature_text("rev1"))
 
1594
 
 
1595
 
 
1596
class TestSmartServerRepositoryAllRevisionIds(
 
1597
    tests.TestCaseWithMemoryTransport):
 
1598
 
 
1599
    def test_empty(self):
 
1600
        """An empty body should be returned for an empty repository."""
 
1601
        backing = self.get_transport()
 
1602
        request = smart_repo.SmartServerRepositoryAllRevisionIds(backing)
 
1603
        self.make_repository('.')
 
1604
        self.assertEqual(
 
1605
            smart_req.SuccessfulSmartServerResponse(("ok", ), ""),
 
1606
            request.execute(''))
 
1607
 
 
1608
    def test_some_revisions(self):
 
1609
        """An empty body should be returned for an empty repository."""
 
1610
        backing = self.get_transport()
 
1611
        request = smart_repo.SmartServerRepositoryAllRevisionIds(backing)
 
1612
        tree = self.make_branch_and_memory_tree('.')
 
1613
        tree.lock_write()
 
1614
        tree.add('')
 
1615
        tree.commit(rev_id='origineel', message="message")
 
1616
        tree.commit(rev_id='nog-een-revisie', message="message")
 
1617
        tree.unlock()
 
1618
        self.assertEqual(
 
1619
            smart_req.SuccessfulSmartServerResponse(("ok", ),
 
1620
                "origineel\nnog-een-revisie"),
 
1621
            request.execute(''))
 
1622
 
 
1623
 
 
1624
class TestSmartServerRepositoryBreakLock(tests.TestCaseWithMemoryTransport):
 
1625
 
 
1626
    def test_lock_to_break(self):
 
1627
        backing = self.get_transport()
 
1628
        request = smart_repo.SmartServerRepositoryBreakLock(backing)
 
1629
        tree = self.make_branch_and_memory_tree('.')
 
1630
        tree.branch.repository.lock_write()
 
1631
        self.assertEqual(
 
1632
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1633
            request.execute(''))
 
1634
 
 
1635
    def test_nothing_to_break(self):
 
1636
        backing = self.get_transport()
 
1637
        request = smart_repo.SmartServerRepositoryBreakLock(backing)
 
1638
        tree = self.make_branch_and_memory_tree('.')
 
1639
        self.assertEqual(
 
1640
            smart_req.SuccessfulSmartServerResponse(('ok', ), None),
 
1641
            request.execute(''))
 
1642
 
 
1643
 
1123
1644
class TestSmartServerRepositoryGetParentMap(tests.TestCaseWithMemoryTransport):
1124
1645
 
1125
1646
    def test_trivial_bzipped(self):
1126
1647
        # This tests that the wire encoding is actually bzipped
1127
1648
        backing = self.get_transport()
1128
 
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
 
1649
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1129
1650
        tree = self.make_branch_and_memory_tree('.')
1130
1651
 
1131
1652
        self.assertEqual(None,
1132
1653
            request.execute('', 'missing-id'))
1133
1654
        # Note that it returns a body that is bzipped.
1134
1655
        self.assertEqual(
1135
 
            SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
 
1656
            smart_req.SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1136
1657
            request.do_body('\n\n0\n'))
1137
1658
 
1138
1659
    def test_trivial_include_missing(self):
1139
1660
        backing = self.get_transport()
1140
 
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
 
1661
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1141
1662
        tree = self.make_branch_and_memory_tree('.')
1142
1663
 
1143
1664
        self.assertEqual(None,
1144
1665
            request.execute('', 'missing-id', 'include-missing:'))
1145
1666
        self.assertEqual(
1146
 
            SuccessfulSmartServerResponse(('ok', ),
 
1667
            smart_req.SuccessfulSmartServerResponse(('ok', ),
1147
1668
                bz2.compress('missing:missing-id')),
1148
1669
            request.do_body('\n\n0\n'))
1149
1670
 
1150
1671
 
1151
 
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
 
1672
class TestSmartServerRepositoryGetRevisionGraph(
 
1673
    tests.TestCaseWithMemoryTransport):
1152
1674
 
1153
1675
    def test_none_argument(self):
1154
1676
        backing = self.get_transport()
1155
 
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
 
1677
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
1156
1678
        tree = self.make_branch_and_memory_tree('.')
1157
1679
        tree.lock_write()
1158
1680
        tree.add('')
1167
1689
        response.body = '\n'.join(sorted(response.body.split('\n')))
1168
1690
 
1169
1691
        self.assertEqual(
1170
 
            SmartServerResponse(('ok', ), '\n'.join(lines)), response)
 
1692
            smart_req.SmartServerResponse(('ok', ), '\n'.join(lines)), response)
1171
1693
 
1172
1694
    def test_specific_revision_argument(self):
1173
1695
        backing = self.get_transport()
1174
 
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
 
1696
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
1175
1697
        tree = self.make_branch_and_memory_tree('.')
1176
1698
        tree.lock_write()
1177
1699
        tree.add('')
1180
1702
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1181
1703
        tree.unlock()
1182
1704
 
1183
 
        self.assertEqual(SmartServerResponse(('ok', ), rev_id_utf8),
 
1705
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), rev_id_utf8),
1184
1706
            request.execute('', rev_id_utf8))
1185
1707
 
1186
1708
    def test_no_such_revision(self):
1187
1709
        backing = self.get_transport()
1188
 
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
 
1710
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
1189
1711
        tree = self.make_branch_and_memory_tree('.')
1190
1712
        tree.lock_write()
1191
1713
        tree.add('')
1193
1715
        tree.unlock()
1194
1716
 
1195
1717
        # Note that it still returns body (of zero bytes).
1196
 
        self.assertEqual(
1197
 
            SmartServerResponse(('nosuchrevision', 'missingrevision', ), ''),
1198
 
            request.execute('', 'missingrevision'))
1199
 
 
1200
 
 
1201
 
class TestSmartServerRepositoryGetRevIdForRevno(tests.TestCaseWithMemoryTransport):
 
1718
        self.assertEqual(smart_req.SmartServerResponse(
 
1719
                ('nosuchrevision', 'missingrevision', ), ''),
 
1720
                         request.execute('', 'missingrevision'))
 
1721
 
 
1722
 
 
1723
class TestSmartServerRepositoryGetRevIdForRevno(
 
1724
    tests.TestCaseWithMemoryTransport):
1202
1725
 
1203
1726
    def test_revno_found(self):
1204
1727
        backing = self.get_transport()
1205
 
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
 
1728
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1206
1729
        tree = self.make_branch_and_memory_tree('.')
1207
1730
        tree.lock_write()
1208
1731
        tree.add('')
1212
1735
        tree.commit('2nd commit', rev_id=rev2_id_utf8)
1213
1736
        tree.unlock()
1214
1737
 
1215
 
        self.assertEqual(SmartServerResponse(('ok', rev1_id_utf8)),
 
1738
        self.assertEqual(smart_req.SmartServerResponse(('ok', rev1_id_utf8)),
1216
1739
            request.execute('', 1, (2, rev2_id_utf8)))
1217
1740
 
1218
1741
    def test_known_revid_missing(self):
1219
1742
        backing = self.get_transport()
1220
 
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
 
1743
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1221
1744
        repo = self.make_repository('.')
1222
1745
        self.assertEqual(
1223
 
            FailedSmartServerResponse(('nosuchrevision', 'ghost')),
 
1746
            smart_req.FailedSmartServerResponse(('nosuchrevision', 'ghost')),
1224
1747
            request.execute('', 1, (2, 'ghost')))
1225
1748
 
1226
1749
    def test_history_incomplete(self):
1227
1750
        backing = self.get_transport()
1228
 
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
 
1751
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1229
1752
        parent = self.make_branch_and_memory_tree('parent', format='1.9')
1230
1753
        parent.lock_write()
1231
1754
        parent.add([''], ['TREE_ROOT'])
1239
1762
        local.branch.create_clone_on_transport(
1240
1763
            self.get_transport('stacked'), stacked_on=self.get_url('parent'))
1241
1764
        self.assertEqual(
1242
 
            SmartServerResponse(('history-incomplete', 2, r2)),
 
1765
            smart_req.SmartServerResponse(('history-incomplete', 2, r2)),
1243
1766
            request.execute('stacked', 1, (3, r3)))
1244
1767
 
1245
 
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
 
1768
 
 
1769
class TestSmartServerRepositoryIterRevisions(
 
1770
    tests.TestCaseWithMemoryTransport):
 
1771
 
 
1772
    def test_basic(self):
 
1773
        backing = self.get_transport()
 
1774
        request = smart_repo.SmartServerRepositoryIterRevisions(backing)
 
1775
        tree = self.make_branch_and_memory_tree('.', format='2a')
 
1776
        tree.lock_write()
 
1777
        tree.add('')
 
1778
        tree.commit('1st commit', rev_id="rev1")
 
1779
        tree.commit('2nd commit', rev_id="rev2")
 
1780
        tree.unlock()
 
1781
 
 
1782
        self.assertIs(None, request.execute(''))
 
1783
        response = request.do_body("rev1\nrev2")
 
1784
        self.assertTrue(response.is_successful())
 
1785
        # Format 2a uses serializer format 10
 
1786
        self.assertEqual(response.args, ("ok", "10"))
 
1787
 
 
1788
        self.addCleanup(tree.branch.lock_read().unlock)
 
1789
        entries = [zlib.compress(record.get_bytes_as("fulltext")) for record in
 
1790
            tree.branch.repository.revisions.get_record_stream(
 
1791
            [("rev1", ), ("rev2", )], "unordered", True)]
 
1792
 
 
1793
        contents = "".join(response.body_stream)
 
1794
        self.assertTrue(contents in (
 
1795
            "".join([entries[0], entries[1]]),
 
1796
            "".join([entries[1], entries[0]])))
 
1797
 
 
1798
    def test_missing(self):
 
1799
        backing = self.get_transport()
 
1800
        request = smart_repo.SmartServerRepositoryIterRevisions(backing)
 
1801
        tree = self.make_branch_and_memory_tree('.', format='2a')
 
1802
 
 
1803
        self.assertIs(None, request.execute(''))
 
1804
        response = request.do_body("rev1\nrev2")
 
1805
        self.assertTrue(response.is_successful())
 
1806
        # Format 2a uses serializer format 10
 
1807
        self.assertEqual(response.args, ("ok", "10"))
 
1808
 
 
1809
        contents = "".join(response.body_stream)
 
1810
        self.assertEqual(contents, "")
 
1811
 
 
1812
 
 
1813
class GetStreamTestBase(tests.TestCaseWithMemoryTransport):
1246
1814
 
1247
1815
    def make_two_commit_repo(self):
1248
1816
        tree = self.make_branch_and_memory_tree('.')
1254
1822
        repo = tree.branch.repository
1255
1823
        return repo, r1, r2
1256
1824
 
 
1825
 
 
1826
class TestSmartServerRepositoryGetStream(GetStreamTestBase):
 
1827
 
1257
1828
    def test_ancestry_of(self):
1258
1829
        """The search argument may be a 'ancestry-of' some heads'."""
1259
1830
        backing = self.get_transport()
1260
 
        request = smart.repository.SmartServerRepositoryGetStream(backing)
 
1831
        request = smart_repo.SmartServerRepositoryGetStream(backing)
1261
1832
        repo, r1, r2 = self.make_two_commit_repo()
1262
1833
        fetch_spec = ['ancestry-of', r2]
1263
1834
        lines = '\n'.join(fetch_spec)
1270
1841
    def test_search(self):
1271
1842
        """The search argument may be a 'search' of some explicit keys."""
1272
1843
        backing = self.get_transport()
1273
 
        request = smart.repository.SmartServerRepositoryGetStream(backing)
 
1844
        request = smart_repo.SmartServerRepositoryGetStream(backing)
1274
1845
        repo, r1, r2 = self.make_two_commit_repo()
1275
1846
        fetch_spec = ['search', '%s %s' % (r1, r2), 'null:', '2']
1276
1847
        lines = '\n'.join(fetch_spec)
1280
1851
        stream_bytes = ''.join(response.body_stream)
1281
1852
        self.assertStartsWith(stream_bytes, 'Bazaar pack format 1')
1282
1853
 
 
1854
    def test_search_everything(self):
 
1855
        """A search of 'everything' returns a stream."""
 
1856
        backing = self.get_transport()
 
1857
        request = smart_repo.SmartServerRepositoryGetStream_1_19(backing)
 
1858
        repo, r1, r2 = self.make_two_commit_repo()
 
1859
        serialised_fetch_spec = 'everything'
 
1860
        request.execute('', repo._format.network_name())
 
1861
        response = request.do_body(serialised_fetch_spec)
 
1862
        self.assertEqual(('ok',), response.args)
 
1863
        stream_bytes = ''.join(response.body_stream)
 
1864
        self.assertStartsWith(stream_bytes, 'Bazaar pack format 1')
 
1865
 
1283
1866
 
1284
1867
class TestSmartServerRequestHasRevision(tests.TestCaseWithMemoryTransport):
1285
1868
 
1286
1869
    def test_missing_revision(self):
1287
1870
        """For a missing revision, ('no', ) is returned."""
1288
1871
        backing = self.get_transport()
1289
 
        request = smart.repository.SmartServerRequestHasRevision(backing)
 
1872
        request = smart_repo.SmartServerRequestHasRevision(backing)
1290
1873
        self.make_repository('.')
1291
 
        self.assertEqual(SmartServerResponse(('no', )),
 
1874
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
1292
1875
            request.execute('', 'revid'))
1293
1876
 
1294
1877
    def test_present_revision(self):
1295
1878
        """For a present revision, ('yes', ) is returned."""
1296
1879
        backing = self.get_transport()
1297
 
        request = smart.repository.SmartServerRequestHasRevision(backing)
 
1880
        request = smart_repo.SmartServerRequestHasRevision(backing)
1298
1881
        tree = self.make_branch_and_memory_tree('.')
1299
1882
        tree.lock_write()
1300
1883
        tree.add('')
1302
1885
        r1 = tree.commit('a commit', rev_id=rev_id_utf8)
1303
1886
        tree.unlock()
1304
1887
        self.assertTrue(tree.branch.repository.has_revision(rev_id_utf8))
1305
 
        self.assertEqual(SmartServerResponse(('yes', )),
 
1888
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
1306
1889
            request.execute('', rev_id_utf8))
1307
1890
 
1308
1891
 
 
1892
class TestSmartServerRepositoryIterFilesBytes(tests.TestCaseWithTransport):
 
1893
 
 
1894
    def test_single(self):
 
1895
        backing = self.get_transport()
 
1896
        request = smart_repo.SmartServerRepositoryIterFilesBytes(backing)
 
1897
        t = self.make_branch_and_tree('.')
 
1898
        self.addCleanup(t.lock_write().unlock)
 
1899
        self.build_tree_contents([("file", "somecontents")])
 
1900
        t.add(["file"], ["thefileid"])
 
1901
        t.commit(rev_id='somerev', message="add file")
 
1902
        self.assertIs(None, request.execute(''))
 
1903
        response = request.do_body("thefileid\0somerev\n")
 
1904
        self.assertTrue(response.is_successful())
 
1905
        self.assertEqual(response.args, ("ok", ))
 
1906
        self.assertEqual("".join(response.body_stream),
 
1907
            "ok\x000\n" + zlib.compress("somecontents"))
 
1908
 
 
1909
    def test_missing(self):
 
1910
        backing = self.get_transport()
 
1911
        request = smart_repo.SmartServerRepositoryIterFilesBytes(backing)
 
1912
        t = self.make_branch_and_tree('.')
 
1913
        self.addCleanup(t.lock_write().unlock)
 
1914
        self.assertIs(None, request.execute(''))
 
1915
        response = request.do_body("thefileid\0revision\n")
 
1916
        self.assertTrue(response.is_successful())
 
1917
        self.assertEqual(response.args, ("ok", ))
 
1918
        self.assertEqual("".join(response.body_stream),
 
1919
            "absent\x00thefileid\x00revision\x000\n")
 
1920
 
 
1921
 
 
1922
class TestSmartServerRequestHasSignatureForRevisionId(
 
1923
        tests.TestCaseWithMemoryTransport):
 
1924
 
 
1925
    def test_missing_revision(self):
 
1926
        """For a missing revision, NoSuchRevision is returned."""
 
1927
        backing = self.get_transport()
 
1928
        request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
 
1929
            backing)
 
1930
        self.make_repository('.')
 
1931
        self.assertEqual(
 
1932
            smart_req.FailedSmartServerResponse(
 
1933
                ('nosuchrevision', 'revid'), None),
 
1934
            request.execute('', 'revid'))
 
1935
 
 
1936
    def test_missing_signature(self):
 
1937
        """For a missing signature, ('no', ) is returned."""
 
1938
        backing = self.get_transport()
 
1939
        request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
 
1940
            backing)
 
1941
        tree = self.make_branch_and_memory_tree('.')
 
1942
        tree.lock_write()
 
1943
        tree.add('')
 
1944
        r1 = tree.commit('a commit', rev_id='A')
 
1945
        tree.unlock()
 
1946
        self.assertTrue(tree.branch.repository.has_revision('A'))
 
1947
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1948
            request.execute('', 'A'))
 
1949
 
 
1950
    def test_present_signature(self):
 
1951
        """For a present signature, ('yes', ) is returned."""
 
1952
        backing = self.get_transport()
 
1953
        request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
 
1954
            backing)
 
1955
        strategy = gpg.LoopbackGPGStrategy(None)
 
1956
        tree = self.make_branch_and_memory_tree('.')
 
1957
        tree.lock_write()
 
1958
        tree.add('')
 
1959
        r1 = tree.commit('a commit', rev_id='A')
 
1960
        tree.branch.repository.start_write_group()
 
1961
        tree.branch.repository.sign_revision('A', strategy)
 
1962
        tree.branch.repository.commit_write_group()
 
1963
        tree.unlock()
 
1964
        self.assertTrue(tree.branch.repository.has_revision('A'))
 
1965
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1966
            request.execute('', 'A'))
 
1967
 
 
1968
 
1309
1969
class TestSmartServerRepositoryGatherStats(tests.TestCaseWithMemoryTransport):
1310
1970
 
1311
1971
    def test_empty_revid(self):
1312
1972
        """With an empty revid, we get only size an number and revisions"""
1313
1973
        backing = self.get_transport()
1314
 
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
 
1974
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
1315
1975
        repository = self.make_repository('.')
1316
1976
        stats = repository.gather_stats()
1317
1977
        expected_body = 'revisions: 0\n'
1318
 
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
 
1978
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
1319
1979
                         request.execute('', '', 'no'))
1320
1980
 
1321
1981
    def test_revid_with_committers(self):
1322
1982
        """For a revid we get more infos."""
1323
1983
        backing = self.get_transport()
1324
1984
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1325
 
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
 
1985
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
1326
1986
        tree = self.make_branch_and_memory_tree('.')
1327
1987
        tree.lock_write()
1328
1988
        tree.add('')
1336
1996
        expected_body = ('firstrev: 123456.200 3600\n'
1337
1997
                         'latestrev: 654321.400 0\n'
1338
1998
                         'revisions: 2\n')
1339
 
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
 
1999
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
1340
2000
                         request.execute('',
1341
2001
                                         rev_id_utf8, 'no'))
1342
2002
 
1344
2004
        """For a revid and requesting committers we get the whole thing."""
1345
2005
        backing = self.get_transport()
1346
2006
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1347
 
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
 
2007
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
1348
2008
        tree = self.make_branch_and_memory_tree('.')
1349
2009
        tree.lock_write()
1350
2010
        tree.add('')
1360
2020
                         'firstrev: 123456.200 3600\n'
1361
2021
                         'latestrev: 654321.400 0\n'
1362
2022
                         'revisions: 2\n')
1363
 
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
 
2023
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
1364
2024
                         request.execute('',
1365
2025
                                         rev_id_utf8, 'yes'))
1366
2026
 
 
2027
    def test_unknown_revid(self):
 
2028
        """An unknown revision id causes a 'nosuchrevision' error."""
 
2029
        backing = self.get_transport()
 
2030
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
2031
        repository = self.make_repository('.')
 
2032
        expected_body = 'revisions: 0\n'
 
2033
        self.assertEqual(
 
2034
            smart_req.FailedSmartServerResponse(
 
2035
                ('nosuchrevision', 'mia'), None),
 
2036
            request.execute('', 'mia', 'yes'))
 
2037
 
1367
2038
 
1368
2039
class TestSmartServerRepositoryIsShared(tests.TestCaseWithMemoryTransport):
1369
2040
 
1370
2041
    def test_is_shared(self):
1371
2042
        """For a shared repository, ('yes', ) is returned."""
1372
2043
        backing = self.get_transport()
1373
 
        request = smart.repository.SmartServerRepositoryIsShared(backing)
 
2044
        request = smart_repo.SmartServerRepositoryIsShared(backing)
1374
2045
        self.make_repository('.', shared=True)
1375
 
        self.assertEqual(SmartServerResponse(('yes', )),
 
2046
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
1376
2047
            request.execute('', ))
1377
2048
 
1378
2049
    def test_is_not_shared(self):
1379
2050
        """For a shared repository, ('no', ) is returned."""
1380
2051
        backing = self.get_transport()
1381
 
        request = smart.repository.SmartServerRepositoryIsShared(backing)
 
2052
        request = smart_repo.SmartServerRepositoryIsShared(backing)
1382
2053
        self.make_repository('.', shared=False)
1383
 
        self.assertEqual(SmartServerResponse(('no', )),
 
2054
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
2055
            request.execute('', ))
 
2056
 
 
2057
 
 
2058
class TestSmartServerRepositoryGetRevisionSignatureText(
 
2059
        tests.TestCaseWithMemoryTransport):
 
2060
 
 
2061
    def test_get_signature(self):
 
2062
        backing = self.get_transport()
 
2063
        request = smart_repo.SmartServerRepositoryGetRevisionSignatureText(
 
2064
            backing)
 
2065
        bb = self.make_branch_builder('.')
 
2066
        bb.build_commit(rev_id='A')
 
2067
        repo = bb.get_branch().repository
 
2068
        strategy = gpg.LoopbackGPGStrategy(None)
 
2069
        self.addCleanup(repo.lock_write().unlock)
 
2070
        repo.start_write_group()
 
2071
        repo.sign_revision('A', strategy)
 
2072
        repo.commit_write_group()
 
2073
        expected_body = (
 
2074
            '-----BEGIN PSEUDO-SIGNED CONTENT-----\n' +
 
2075
            Testament.from_revision(repo, 'A').as_short_text() +
 
2076
            '-----END PSEUDO-SIGNED CONTENT-----\n')
 
2077
        self.assertEqual(
 
2078
            smart_req.SmartServerResponse(('ok', ), expected_body),
 
2079
            request.execute('', 'A'))
 
2080
 
 
2081
 
 
2082
class TestSmartServerRepositoryMakeWorkingTrees(
 
2083
        tests.TestCaseWithMemoryTransport):
 
2084
 
 
2085
    def test_make_working_trees(self):
 
2086
        """For a repository with working trees, ('yes', ) is returned."""
 
2087
        backing = self.get_transport()
 
2088
        request = smart_repo.SmartServerRepositoryMakeWorkingTrees(backing)
 
2089
        r = self.make_repository('.')
 
2090
        r.set_make_working_trees(True)
 
2091
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
2092
            request.execute('', ))
 
2093
 
 
2094
    def test_is_not_shared(self):
 
2095
        """For a repository with working trees, ('no', ) is returned."""
 
2096
        backing = self.get_transport()
 
2097
        request = smart_repo.SmartServerRepositoryMakeWorkingTrees(backing)
 
2098
        r = self.make_repository('.')
 
2099
        r.set_make_working_trees(False)
 
2100
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
1384
2101
            request.execute('', ))
1385
2102
 
1386
2103
 
1388
2105
 
1389
2106
    def test_lock_write_on_unlocked_repo(self):
1390
2107
        backing = self.get_transport()
1391
 
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
 
2108
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
1392
2109
        repository = self.make_repository('.', format='knit')
1393
2110
        response = request.execute('')
1394
2111
        nonce = repository.control_files._lock.peek().get('nonce')
1395
 
        self.assertEqual(SmartServerResponse(('ok', nonce)), response)
 
2112
        self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
1396
2113
        # The repository is now locked.  Verify that with a new repository
1397
2114
        # object.
1398
2115
        new_repo = repository.bzrdir.open_repository()
1399
2116
        self.assertRaises(errors.LockContention, new_repo.lock_write)
1400
2117
        # Cleanup
1401
 
        request = smart.repository.SmartServerRepositoryUnlock(backing)
 
2118
        request = smart_repo.SmartServerRepositoryUnlock(backing)
1402
2119
        response = request.execute('', nonce)
1403
2120
 
1404
2121
    def test_lock_write_on_locked_repo(self):
1405
2122
        backing = self.get_transport()
1406
 
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
 
2123
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
1407
2124
        repository = self.make_repository('.', format='knit')
1408
 
        repo_token = repository.lock_write()
 
2125
        repo_token = repository.lock_write().repository_token
1409
2126
        repository.leave_lock_in_place()
1410
2127
        repository.unlock()
1411
2128
        response = request.execute('')
1412
2129
        self.assertEqual(
1413
 
            SmartServerResponse(('LockContention',)), response)
 
2130
            smart_req.SmartServerResponse(('LockContention',)), response)
1414
2131
        # Cleanup
1415
2132
        repository.lock_write(repo_token)
1416
2133
        repository.dont_leave_lock_in_place()
1418
2135
 
1419
2136
    def test_lock_write_on_readonly_transport(self):
1420
2137
        backing = self.get_readonly_transport()
1421
 
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
 
2138
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
1422
2139
        repository = self.make_repository('.', format='knit')
1423
2140
        response = request.execute('')
1424
2141
        self.assertFalse(response.is_successful())
1428
2145
class TestInsertStreamBase(tests.TestCaseWithMemoryTransport):
1429
2146
 
1430
2147
    def make_empty_byte_stream(self, repo):
1431
 
        byte_stream = smart.repository._stream_to_byte_stream([], repo._format)
 
2148
        byte_stream = smart_repo._stream_to_byte_stream([], repo._format)
1432
2149
        return ''.join(byte_stream)
1433
2150
 
1434
2151
 
1436
2153
 
1437
2154
    def test_insert_stream_empty(self):
1438
2155
        backing = self.get_transport()
1439
 
        request = smart.repository.SmartServerRepositoryInsertStream(backing)
 
2156
        request = smart_repo.SmartServerRepositoryInsertStream(backing)
1440
2157
        repository = self.make_repository('.')
1441
2158
        response = request.execute('', '')
1442
2159
        self.assertEqual(None, response)
1443
2160
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1444
2161
        self.assertEqual(None, response)
1445
2162
        response = request.do_end()
1446
 
        self.assertEqual(SmartServerResponse(('ok', )), response)
1447
 
        
 
2163
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
 
2164
 
1448
2165
 
1449
2166
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
1450
2167
 
1451
2168
    def test_insert_stream_empty(self):
1452
2169
        backing = self.get_transport()
1453
 
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
 
2170
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1454
2171
            backing)
1455
2172
        repository = self.make_repository('.', format='knit')
1456
 
        lock_token = repository.lock_write()
 
2173
        lock_token = repository.lock_write().repository_token
1457
2174
        response = request.execute('', '', lock_token)
1458
2175
        self.assertEqual(None, response)
1459
2176
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1460
2177
        self.assertEqual(None, response)
1461
2178
        response = request.do_end()
1462
 
        self.assertEqual(SmartServerResponse(('ok', )), response)
 
2179
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1463
2180
        repository.unlock()
1464
2181
 
1465
2182
    def test_insert_stream_with_wrong_lock_token(self):
1466
2183
        backing = self.get_transport()
1467
 
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
 
2184
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1468
2185
            backing)
1469
2186
        repository = self.make_repository('.', format='knit')
1470
 
        lock_token = repository.lock_write()
 
2187
        lock_token = repository.lock_write().repository_token
1471
2188
        self.assertRaises(
1472
2189
            errors.TokenMismatch, request.execute, '', '', 'wrong-token')
1473
2190
        repository.unlock()
1475
2192
 
1476
2193
class TestSmartServerRepositoryUnlock(tests.TestCaseWithMemoryTransport):
1477
2194
 
1478
 
    def setUp(self):
1479
 
        tests.TestCaseWithMemoryTransport.setUp(self)
1480
 
 
1481
2195
    def test_unlock_on_locked_repo(self):
1482
2196
        backing = self.get_transport()
1483
 
        request = smart.repository.SmartServerRepositoryUnlock(backing)
 
2197
        request = smart_repo.SmartServerRepositoryUnlock(backing)
1484
2198
        repository = self.make_repository('.', format='knit')
1485
 
        token = repository.lock_write()
 
2199
        token = repository.lock_write().repository_token
1486
2200
        repository.leave_lock_in_place()
1487
2201
        repository.unlock()
1488
2202
        response = request.execute('', token)
1489
2203
        self.assertEqual(
1490
 
            SmartServerResponse(('ok',)), response)
 
2204
            smart_req.SmartServerResponse(('ok',)), response)
1491
2205
        # The repository is now unlocked.  Verify that with a new repository
1492
2206
        # object.
1493
2207
        new_repo = repository.bzrdir.open_repository()
1496
2210
 
1497
2211
    def test_unlock_on_unlocked_repo(self):
1498
2212
        backing = self.get_transport()
1499
 
        request = smart.repository.SmartServerRepositoryUnlock(backing)
 
2213
        request = smart_repo.SmartServerRepositoryUnlock(backing)
1500
2214
        repository = self.make_repository('.', format='knit')
1501
2215
        response = request.execute('', 'some token')
1502
2216
        self.assertEqual(
1503
 
            SmartServerResponse(('TokenMismatch',)), response)
 
2217
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
2218
 
 
2219
 
 
2220
class TestSmartServerRepositoryGetPhysicalLockStatus(
 
2221
    tests.TestCaseWithTransport):
 
2222
 
 
2223
    def test_with_write_lock(self):
 
2224
        backing = self.get_transport()
 
2225
        repo = self.make_repository('.')
 
2226
        self.addCleanup(repo.lock_write().unlock)
 
2227
        # lock_write() doesn't necessarily actually take a physical
 
2228
        # lock out.
 
2229
        if repo.get_physical_lock_status():
 
2230
            expected = 'yes'
 
2231
        else:
 
2232
            expected = 'no'
 
2233
        request_class = smart_repo.SmartServerRepositoryGetPhysicalLockStatus
 
2234
        request = request_class(backing)
 
2235
        self.assertEqual(smart_req.SuccessfulSmartServerResponse((expected,)),
 
2236
            request.execute('', ))
 
2237
 
 
2238
    def test_without_write_lock(self):
 
2239
        backing = self.get_transport()
 
2240
        repo = self.make_repository('.')
 
2241
        self.assertEqual(False, repo.get_physical_lock_status())
 
2242
        request_class = smart_repo.SmartServerRepositoryGetPhysicalLockStatus
 
2243
        request = request_class(backing)
 
2244
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('no',)),
 
2245
            request.execute('', ))
 
2246
 
 
2247
 
 
2248
class TestSmartServerRepositoryReconcile(tests.TestCaseWithTransport):
 
2249
 
 
2250
    def test_reconcile(self):
 
2251
        backing = self.get_transport()
 
2252
        repo = self.make_repository('.')
 
2253
        token = repo.lock_write().repository_token
 
2254
        self.addCleanup(repo.unlock)
 
2255
        request_class = smart_repo.SmartServerRepositoryReconcile
 
2256
        request = request_class(backing)
 
2257
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
 
2258
            ('ok', ),
 
2259
             'garbage_inventories: 0\n'
 
2260
             'inconsistent_parents: 0\n'),
 
2261
            request.execute('', token))
1504
2262
 
1505
2263
 
1506
2264
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1507
2265
 
1508
2266
    def test_is_readonly_no(self):
1509
2267
        backing = self.get_transport()
1510
 
        request = smart.request.SmartServerIsReadonly(backing)
 
2268
        request = smart_req.SmartServerIsReadonly(backing)
1511
2269
        response = request.execute()
1512
2270
        self.assertEqual(
1513
 
            SmartServerResponse(('no',)), response)
 
2271
            smart_req.SmartServerResponse(('no',)), response)
1514
2272
 
1515
2273
    def test_is_readonly_yes(self):
1516
2274
        backing = self.get_readonly_transport()
1517
 
        request = smart.request.SmartServerIsReadonly(backing)
 
2275
        request = smart_req.SmartServerIsReadonly(backing)
1518
2276
        response = request.execute()
1519
2277
        self.assertEqual(
1520
 
            SmartServerResponse(('yes',)), response)
1521
 
 
1522
 
 
1523
 
class TestSmartServerRepositorySetMakeWorkingTrees(tests.TestCaseWithMemoryTransport):
 
2278
            smart_req.SmartServerResponse(('yes',)), response)
 
2279
 
 
2280
 
 
2281
class TestSmartServerRepositorySetMakeWorkingTrees(
 
2282
    tests.TestCaseWithMemoryTransport):
1524
2283
 
1525
2284
    def test_set_false(self):
1526
2285
        backing = self.get_transport()
1527
2286
        repo = self.make_repository('.', shared=True)
1528
2287
        repo.set_make_working_trees(True)
1529
 
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
 
2288
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
1530
2289
        request = request_class(backing)
1531
 
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
 
2290
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
1532
2291
            request.execute('', 'False'))
1533
2292
        repo = repo.bzrdir.open_repository()
1534
2293
        self.assertFalse(repo.make_working_trees())
1537
2296
        backing = self.get_transport()
1538
2297
        repo = self.make_repository('.', shared=True)
1539
2298
        repo.set_make_working_trees(False)
1540
 
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
 
2299
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
1541
2300
        request = request_class(backing)
1542
 
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
 
2301
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
1543
2302
            request.execute('', 'True'))
1544
2303
        repo = repo.bzrdir.open_repository()
1545
2304
        self.assertTrue(repo.make_working_trees())
1546
2305
 
1547
2306
 
 
2307
class TestSmartServerRepositoryGetSerializerFormat(
 
2308
    tests.TestCaseWithMemoryTransport):
 
2309
 
 
2310
    def test_get_serializer_format(self):
 
2311
        backing = self.get_transport()
 
2312
        repo = self.make_repository('.', format='2a')
 
2313
        request_class = smart_repo.SmartServerRepositoryGetSerializerFormat
 
2314
        request = request_class(backing)
 
2315
        self.assertEqual(
 
2316
            smart_req.SuccessfulSmartServerResponse(('ok', '10')),
 
2317
            request.execute(''))
 
2318
 
 
2319
 
 
2320
class TestSmartServerRepositoryWriteGroup(
 
2321
    tests.TestCaseWithMemoryTransport):
 
2322
 
 
2323
    def test_start_write_group(self):
 
2324
        backing = self.get_transport()
 
2325
        repo = self.make_repository('.')
 
2326
        lock_token = repo.lock_write().repository_token
 
2327
        self.addCleanup(repo.unlock)
 
2328
        request_class = smart_repo.SmartServerRepositoryStartWriteGroup
 
2329
        request = request_class(backing)
 
2330
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok', [])),
 
2331
            request.execute('', lock_token))
 
2332
 
 
2333
    def test_start_write_group_unsuspendable(self):
 
2334
        backing = self.get_transport()
 
2335
        repo = self.make_repository('.', format='knit')
 
2336
        lock_token = repo.lock_write().repository_token
 
2337
        self.addCleanup(repo.unlock)
 
2338
        request_class = smart_repo.SmartServerRepositoryStartWriteGroup
 
2339
        request = request_class(backing)
 
2340
        self.assertEqual(
 
2341
            smart_req.FailedSmartServerResponse(('UnsuspendableWriteGroup',)),
 
2342
            request.execute('', lock_token))
 
2343
 
 
2344
    def test_commit_write_group(self):
 
2345
        backing = self.get_transport()
 
2346
        repo = self.make_repository('.')
 
2347
        lock_token = repo.lock_write().repository_token
 
2348
        self.addCleanup(repo.unlock)
 
2349
        repo.start_write_group()
 
2350
        tokens = repo.suspend_write_group()
 
2351
        request_class = smart_repo.SmartServerRepositoryCommitWriteGroup
 
2352
        request = request_class(backing)
 
2353
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
2354
            request.execute('', lock_token, tokens))
 
2355
 
 
2356
    def test_abort_write_group(self):
 
2357
        backing = self.get_transport()
 
2358
        repo = self.make_repository('.')
 
2359
        lock_token = repo.lock_write().repository_token
 
2360
        repo.start_write_group()
 
2361
        tokens = repo.suspend_write_group()
 
2362
        self.addCleanup(repo.unlock)
 
2363
        request_class = smart_repo.SmartServerRepositoryAbortWriteGroup
 
2364
        request = request_class(backing)
 
2365
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
2366
            request.execute('', lock_token, tokens))
 
2367
 
 
2368
    def test_check_write_group(self):
 
2369
        backing = self.get_transport()
 
2370
        repo = self.make_repository('.')
 
2371
        lock_token = repo.lock_write().repository_token
 
2372
        repo.start_write_group()
 
2373
        tokens = repo.suspend_write_group()
 
2374
        self.addCleanup(repo.unlock)
 
2375
        request_class = smart_repo.SmartServerRepositoryCheckWriteGroup
 
2376
        request = request_class(backing)
 
2377
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
2378
            request.execute('', lock_token, tokens))
 
2379
 
 
2380
    def test_check_write_group_invalid(self):
 
2381
        backing = self.get_transport()
 
2382
        repo = self.make_repository('.')
 
2383
        lock_token = repo.lock_write().repository_token
 
2384
        self.addCleanup(repo.unlock)
 
2385
        request_class = smart_repo.SmartServerRepositoryCheckWriteGroup
 
2386
        request = request_class(backing)
 
2387
        self.assertEqual(smart_req.FailedSmartServerResponse(
 
2388
            ('UnresumableWriteGroup', ['random'],
 
2389
                'Malformed write group token')),
 
2390
            request.execute('', lock_token, ["random"]))
 
2391
 
 
2392
 
1548
2393
class TestSmartServerPackRepositoryAutopack(tests.TestCaseWithTransport):
1549
2394
 
1550
2395
    def make_repo_needing_autopacking(self, path='.'):
1564
2409
        repo.lock_write()
1565
2410
        self.addCleanup(repo.unlock)
1566
2411
        backing = self.get_transport()
1567
 
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
 
2412
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
1568
2413
            backing)
1569
2414
        response = request.execute('')
1570
 
        self.assertEqual(SmartServerResponse(('ok',)), response)
 
2415
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
1571
2416
        repo._pack_collection.reload_pack_names()
1572
2417
        self.assertEqual(1, len(repo._pack_collection.names()))
1573
2418
 
1579
2424
        for x in range(9):
1580
2425
            tree.commit('commit %s' % x)
1581
2426
        backing = self.get_transport()
1582
 
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
 
2427
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
1583
2428
            backing)
1584
2429
        response = request.execute('')
1585
 
        self.assertEqual(SmartServerResponse(('ok',)), response)
 
2430
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
1586
2431
        repo._pack_collection.reload_pack_names()
1587
2432
        self.assertEqual(9, len(repo._pack_collection.names()))
1588
2433
 
1590
2435
        """A request to autopack a non-pack repo is a no-op."""
1591
2436
        repo = self.make_repository('.', format='knit')
1592
2437
        backing = self.get_transport()
1593
 
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
 
2438
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
1594
2439
            backing)
1595
2440
        response = request.execute('')
1596
 
        self.assertEqual(SmartServerResponse(('ok',)), response)
 
2441
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
2442
 
 
2443
 
 
2444
class TestSmartServerVfsGet(tests.TestCaseWithMemoryTransport):
 
2445
 
 
2446
    def test_unicode_path(self):
 
2447
        """VFS requests expect unicode paths to be escaped."""
 
2448
        filename = u'foo\N{INTERROBANG}'
 
2449
        filename_escaped = urlutils.escape(filename)
 
2450
        backing = self.get_transport()
 
2451
        request = vfs.GetRequest(backing)
 
2452
        backing.put_bytes_non_atomic(filename_escaped, 'contents')
 
2453
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'contents'),
 
2454
            request.execute(filename_escaped))
1597
2455
 
1598
2456
 
1599
2457
class TestHandlers(tests.TestCase):
1603
2461
        """All registered request_handlers can be found."""
1604
2462
        # If there's a typo in a register_lazy call, this loop will fail with
1605
2463
        # an AttributeError.
1606
 
        for key, item in smart.request.request_handlers.iteritems():
1607
 
            pass
 
2464
        for key in smart_req.request_handlers.keys():
 
2465
            try:
 
2466
                item = smart_req.request_handlers.get(key)
 
2467
            except AttributeError, e:
 
2468
                raise AttributeError('failed to get %s: %s' % (key, e))
1608
2469
 
1609
2470
    def assertHandlerEqual(self, verb, handler):
1610
 
        self.assertEqual(smart.request.request_handlers.get(verb), handler)
 
2471
        self.assertEqual(smart_req.request_handlers.get(verb), handler)
1611
2472
 
1612
2473
    def test_registered_methods(self):
1613
2474
        """Test that known methods are registered to the correct object."""
 
2475
        self.assertHandlerEqual('Branch.break_lock',
 
2476
            smart_branch.SmartServerBranchBreakLock)
1614
2477
        self.assertHandlerEqual('Branch.get_config_file',
1615
 
            smart.branch.SmartServerBranchGetConfigFile)
 
2478
            smart_branch.SmartServerBranchGetConfigFile)
 
2479
        self.assertHandlerEqual('Branch.put_config_file',
 
2480
            smart_branch.SmartServerBranchPutConfigFile)
1616
2481
        self.assertHandlerEqual('Branch.get_parent',
1617
 
            smart.branch.SmartServerBranchGetParent)
 
2482
            smart_branch.SmartServerBranchGetParent)
 
2483
        self.assertHandlerEqual('Branch.get_physical_lock_status',
 
2484
            smart_branch.SmartServerBranchRequestGetPhysicalLockStatus)
1618
2485
        self.assertHandlerEqual('Branch.get_tags_bytes',
1619
 
            smart.branch.SmartServerBranchGetTagsBytes)
 
2486
            smart_branch.SmartServerBranchGetTagsBytes)
1620
2487
        self.assertHandlerEqual('Branch.lock_write',
1621
 
            smart.branch.SmartServerBranchRequestLockWrite)
 
2488
            smart_branch.SmartServerBranchRequestLockWrite)
1622
2489
        self.assertHandlerEqual('Branch.last_revision_info',
1623
 
            smart.branch.SmartServerBranchRequestLastRevisionInfo)
 
2490
            smart_branch.SmartServerBranchRequestLastRevisionInfo)
1624
2491
        self.assertHandlerEqual('Branch.revision_history',
1625
 
            smart.branch.SmartServerRequestRevisionHistory)
 
2492
            smart_branch.SmartServerRequestRevisionHistory)
 
2493
        self.assertHandlerEqual('Branch.revision_id_to_revno',
 
2494
            smart_branch.SmartServerBranchRequestRevisionIdToRevno)
1626
2495
        self.assertHandlerEqual('Branch.set_config_option',
1627
 
            smart.branch.SmartServerBranchRequestSetConfigOption)
 
2496
            smart_branch.SmartServerBranchRequestSetConfigOption)
1628
2497
        self.assertHandlerEqual('Branch.set_last_revision',
1629
 
            smart.branch.SmartServerBranchRequestSetLastRevision)
 
2498
            smart_branch.SmartServerBranchRequestSetLastRevision)
1630
2499
        self.assertHandlerEqual('Branch.set_last_revision_info',
1631
 
            smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
 
2500
            smart_branch.SmartServerBranchRequestSetLastRevisionInfo)
1632
2501
        self.assertHandlerEqual('Branch.set_last_revision_ex',
1633
 
            smart.branch.SmartServerBranchRequestSetLastRevisionEx)
 
2502
            smart_branch.SmartServerBranchRequestSetLastRevisionEx)
1634
2503
        self.assertHandlerEqual('Branch.set_parent_location',
1635
 
            smart.branch.SmartServerBranchRequestSetParentLocation)
 
2504
            smart_branch.SmartServerBranchRequestSetParentLocation)
1636
2505
        self.assertHandlerEqual('Branch.unlock',
1637
 
            smart.branch.SmartServerBranchRequestUnlock)
 
2506
            smart_branch.SmartServerBranchRequestUnlock)
 
2507
        self.assertHandlerEqual('BzrDir.destroy_branch',
 
2508
            smart_dir.SmartServerBzrDirRequestDestroyBranch)
1638
2509
        self.assertHandlerEqual('BzrDir.find_repository',
1639
 
            smart.bzrdir.SmartServerRequestFindRepositoryV1)
 
2510
            smart_dir.SmartServerRequestFindRepositoryV1)
1640
2511
        self.assertHandlerEqual('BzrDir.find_repositoryV2',
1641
 
            smart.bzrdir.SmartServerRequestFindRepositoryV2)
 
2512
            smart_dir.SmartServerRequestFindRepositoryV2)
1642
2513
        self.assertHandlerEqual('BzrDirFormat.initialize',
1643
 
            smart.bzrdir.SmartServerRequestInitializeBzrDir)
 
2514
            smart_dir.SmartServerRequestInitializeBzrDir)
1644
2515
        self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
1645
 
            smart.bzrdir.SmartServerRequestBzrDirInitializeEx)
 
2516
            smart_dir.SmartServerRequestBzrDirInitializeEx)
 
2517
        self.assertHandlerEqual('BzrDir.checkout_metadir',
 
2518
            smart_dir.SmartServerBzrDirRequestCheckoutMetaDir)
1646
2519
        self.assertHandlerEqual('BzrDir.cloning_metadir',
1647
 
            smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
 
2520
            smart_dir.SmartServerBzrDirRequestCloningMetaDir)
 
2521
        self.assertHandlerEqual('BzrDir.get_branches',
 
2522
            smart_dir.SmartServerBzrDirRequestGetBranches)
1648
2523
        self.assertHandlerEqual('BzrDir.get_config_file',
1649
 
            smart.bzrdir.SmartServerBzrDirRequestConfigFile)
 
2524
            smart_dir.SmartServerBzrDirRequestConfigFile)
1650
2525
        self.assertHandlerEqual('BzrDir.open_branch',
1651
 
            smart.bzrdir.SmartServerRequestOpenBranch)
 
2526
            smart_dir.SmartServerRequestOpenBranch)
1652
2527
        self.assertHandlerEqual('BzrDir.open_branchV2',
1653
 
            smart.bzrdir.SmartServerRequestOpenBranchV2)
 
2528
            smart_dir.SmartServerRequestOpenBranchV2)
 
2529
        self.assertHandlerEqual('BzrDir.open_branchV3',
 
2530
            smart_dir.SmartServerRequestOpenBranchV3)
1654
2531
        self.assertHandlerEqual('PackRepository.autopack',
1655
 
            smart.packrepository.SmartServerPackRepositoryAutopack)
 
2532
            smart_packrepo.SmartServerPackRepositoryAutopack)
 
2533
        self.assertHandlerEqual('Repository.add_signature_text',
 
2534
            smart_repo.SmartServerRepositoryAddSignatureText)
 
2535
        self.assertHandlerEqual('Repository.all_revision_ids',
 
2536
            smart_repo.SmartServerRepositoryAllRevisionIds)
 
2537
        self.assertHandlerEqual('Repository.break_lock',
 
2538
            smart_repo.SmartServerRepositoryBreakLock)
1656
2539
        self.assertHandlerEqual('Repository.gather_stats',
1657
 
            smart.repository.SmartServerRepositoryGatherStats)
 
2540
            smart_repo.SmartServerRepositoryGatherStats)
1658
2541
        self.assertHandlerEqual('Repository.get_parent_map',
1659
 
            smart.repository.SmartServerRepositoryGetParentMap)
 
2542
            smart_repo.SmartServerRepositoryGetParentMap)
 
2543
        self.assertHandlerEqual('Repository.get_physical_lock_status',
 
2544
            smart_repo.SmartServerRepositoryGetPhysicalLockStatus)
1660
2545
        self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1661
 
            smart.repository.SmartServerRepositoryGetRevIdForRevno)
 
2546
            smart_repo.SmartServerRepositoryGetRevIdForRevno)
1662
2547
        self.assertHandlerEqual('Repository.get_revision_graph',
1663
 
            smart.repository.SmartServerRepositoryGetRevisionGraph)
 
2548
            smart_repo.SmartServerRepositoryGetRevisionGraph)
 
2549
        self.assertHandlerEqual('Repository.get_revision_signature_text',
 
2550
            smart_repo.SmartServerRepositoryGetRevisionSignatureText)
1664
2551
        self.assertHandlerEqual('Repository.get_stream',
1665
 
            smart.repository.SmartServerRepositoryGetStream)
 
2552
            smart_repo.SmartServerRepositoryGetStream)
 
2553
        self.assertHandlerEqual('Repository.get_stream_1.19',
 
2554
            smart_repo.SmartServerRepositoryGetStream_1_19)
 
2555
        self.assertHandlerEqual('Repository.iter_revisions',
 
2556
            smart_repo.SmartServerRepositoryIterRevisions)
1666
2557
        self.assertHandlerEqual('Repository.has_revision',
1667
 
            smart.repository.SmartServerRequestHasRevision)
 
2558
            smart_repo.SmartServerRequestHasRevision)
1668
2559
        self.assertHandlerEqual('Repository.insert_stream',
1669
 
            smart.repository.SmartServerRepositoryInsertStream)
 
2560
            smart_repo.SmartServerRepositoryInsertStream)
1670
2561
        self.assertHandlerEqual('Repository.insert_stream_locked',
1671
 
            smart.repository.SmartServerRepositoryInsertStreamLocked)
 
2562
            smart_repo.SmartServerRepositoryInsertStreamLocked)
1672
2563
        self.assertHandlerEqual('Repository.is_shared',
1673
 
            smart.repository.SmartServerRepositoryIsShared)
 
2564
            smart_repo.SmartServerRepositoryIsShared)
 
2565
        self.assertHandlerEqual('Repository.iter_files_bytes',
 
2566
            smart_repo.SmartServerRepositoryIterFilesBytes)
1674
2567
        self.assertHandlerEqual('Repository.lock_write',
1675
 
            smart.repository.SmartServerRepositoryLockWrite)
 
2568
            smart_repo.SmartServerRepositoryLockWrite)
 
2569
        self.assertHandlerEqual('Repository.make_working_trees',
 
2570
            smart_repo.SmartServerRepositoryMakeWorkingTrees)
 
2571
        self.assertHandlerEqual('Repository.pack',
 
2572
            smart_repo.SmartServerRepositoryPack)
 
2573
        self.assertHandlerEqual('Repository.reconcile',
 
2574
            smart_repo.SmartServerRepositoryReconcile)
1676
2575
        self.assertHandlerEqual('Repository.tarball',
1677
 
            smart.repository.SmartServerRepositoryTarball)
 
2576
            smart_repo.SmartServerRepositoryTarball)
1678
2577
        self.assertHandlerEqual('Repository.unlock',
1679
 
            smart.repository.SmartServerRepositoryUnlock)
 
2578
            smart_repo.SmartServerRepositoryUnlock)
 
2579
        self.assertHandlerEqual('Repository.start_write_group',
 
2580
            smart_repo.SmartServerRepositoryStartWriteGroup)
 
2581
        self.assertHandlerEqual('Repository.check_write_group',
 
2582
            smart_repo.SmartServerRepositoryCheckWriteGroup)
 
2583
        self.assertHandlerEqual('Repository.commit_write_group',
 
2584
            smart_repo.SmartServerRepositoryCommitWriteGroup)
 
2585
        self.assertHandlerEqual('Repository.abort_write_group',
 
2586
            smart_repo.SmartServerRepositoryAbortWriteGroup)
 
2587
        self.assertHandlerEqual('VersionedFileRepository.get_serializer_format',
 
2588
            smart_repo.SmartServerRepositoryGetSerializerFormat)
 
2589
        self.assertHandlerEqual('VersionedFileRepository.get_inventories',
 
2590
            smart_repo.SmartServerRepositoryGetInventories)
1680
2591
        self.assertHandlerEqual('Transport.is_readonly',
1681
 
            smart.request.SmartServerIsReadonly)
 
2592
            smart_req.SmartServerIsReadonly)
 
2593
 
 
2594
 
 
2595
class SmartTCPServerHookTests(tests.TestCaseWithMemoryTransport):
 
2596
    """Tests for SmartTCPServer hooks."""
 
2597
 
 
2598
    def setUp(self):
 
2599
        super(SmartTCPServerHookTests, self).setUp()
 
2600
        self.server = server.SmartTCPServer(self.get_transport())
 
2601
 
 
2602
    def test_run_server_started_hooks(self):
 
2603
        """Test the server started hooks get fired properly."""
 
2604
        started_calls = []
 
2605
        server.SmartTCPServer.hooks.install_named_hook('server_started',
 
2606
            lambda backing_urls, url: started_calls.append((backing_urls, url)),
 
2607
            None)
 
2608
        started_ex_calls = []
 
2609
        server.SmartTCPServer.hooks.install_named_hook('server_started_ex',
 
2610
            lambda backing_urls, url: started_ex_calls.append((backing_urls, url)),
 
2611
            None)
 
2612
        self.server._sockname = ('example.com', 42)
 
2613
        self.server.run_server_started_hooks()
 
2614
        self.assertEqual(started_calls,
 
2615
            [([self.get_transport().base], 'bzr://example.com:42/')])
 
2616
        self.assertEqual(started_ex_calls,
 
2617
            [([self.get_transport().base], self.server)])
 
2618
 
 
2619
    def test_run_server_started_hooks_ipv6(self):
 
2620
        """Test that socknames can contain 4-tuples."""
 
2621
        self.server._sockname = ('::', 42, 0, 0)
 
2622
        started_calls = []
 
2623
        server.SmartTCPServer.hooks.install_named_hook('server_started',
 
2624
            lambda backing_urls, url: started_calls.append((backing_urls, url)),
 
2625
            None)
 
2626
        self.server.run_server_started_hooks()
 
2627
        self.assertEqual(started_calls,
 
2628
                [([self.get_transport().base], 'bzr://:::42/')])
 
2629
 
 
2630
    def test_run_server_stopped_hooks(self):
 
2631
        """Test the server stopped hooks."""
 
2632
        self.server._sockname = ('example.com', 42)
 
2633
        stopped_calls = []
 
2634
        server.SmartTCPServer.hooks.install_named_hook('server_stopped',
 
2635
            lambda backing_urls, url: stopped_calls.append((backing_urls, url)),
 
2636
            None)
 
2637
        self.server.run_server_stopped_hooks()
 
2638
        self.assertEqual(stopped_calls,
 
2639
            [([self.get_transport().base], 'bzr://example.com:42/')])
 
2640
 
 
2641
 
 
2642
class TestSmartServerRepositoryPack(tests.TestCaseWithMemoryTransport):
 
2643
 
 
2644
    def test_pack(self):
 
2645
        backing = self.get_transport()
 
2646
        request = smart_repo.SmartServerRepositoryPack(backing)
 
2647
        tree = self.make_branch_and_memory_tree('.')
 
2648
        repo_token = tree.branch.repository.lock_write().repository_token
 
2649
 
 
2650
        self.assertIs(None, request.execute('', repo_token, False))
 
2651
 
 
2652
        self.assertEqual(
 
2653
            smart_req.SuccessfulSmartServerResponse(('ok', ), ),
 
2654
            request.do_body(''))
 
2655
 
 
2656
 
 
2657
class TestSmartServerRepositoryGetInventories(tests.TestCaseWithTransport):
 
2658
 
 
2659
    def _get_serialized_inventory_delta(self, repository, base_revid, revid):
 
2660
        base_inv = repository.revision_tree(base_revid).root_inventory
 
2661
        inv = repository.revision_tree(revid).root_inventory
 
2662
        inv_delta = inv._make_delta(base_inv)
 
2663
        serializer = inventory_delta.InventoryDeltaSerializer(True, False)
 
2664
        return "".join(serializer.delta_to_lines(base_revid, revid, inv_delta))
 
2665
 
 
2666
    def test_single(self):
 
2667
        backing = self.get_transport()
 
2668
        request = smart_repo.SmartServerRepositoryGetInventories(backing)
 
2669
        t = self.make_branch_and_tree('.', format='2a')
 
2670
        self.addCleanup(t.lock_write().unlock)
 
2671
        self.build_tree_contents([("file", "somecontents")])
 
2672
        t.add(["file"], ["thefileid"])
 
2673
        t.commit(rev_id='somerev', message="add file")
 
2674
        self.assertIs(None, request.execute('', 'unordered'))
 
2675
        response = request.do_body("somerev\n")
 
2676
        self.assertTrue(response.is_successful())
 
2677
        self.assertEqual(response.args, ("ok", ))
 
2678
        stream = [('inventory-deltas', [
 
2679
            versionedfile.FulltextContentFactory('somerev', None, None,
 
2680
                self._get_serialized_inventory_delta(
 
2681
                    t.branch.repository, 'null:', 'somerev'))])]
 
2682
        fmt = controldir.format_registry.get('2a')().repository_format
 
2683
        self.assertEqual(
 
2684
            "".join(response.body_stream),
 
2685
            "".join(smart_repo._stream_to_byte_stream(stream, fmt)))
 
2686
 
 
2687
    def test_empty(self):
 
2688
        backing = self.get_transport()
 
2689
        request = smart_repo.SmartServerRepositoryGetInventories(backing)
 
2690
        t = self.make_branch_and_tree('.', format='2a')
 
2691
        self.addCleanup(t.lock_write().unlock)
 
2692
        self.build_tree_contents([("file", "somecontents")])
 
2693
        t.add(["file"], ["thefileid"])
 
2694
        t.commit(rev_id='somerev', message="add file")
 
2695
        self.assertIs(None, request.execute('', 'unordered'))
 
2696
        response = request.do_body("")
 
2697
        self.assertTrue(response.is_successful())
 
2698
        self.assertEqual(response.args, ("ok", ))
 
2699
        self.assertEqual("".join(response.body_stream),
 
2700
            "Bazaar pack format 1 (introduced in 0.18)\nB54\n\nBazaar repository format 2a (needs bzr 1.16 or later)\nE")