/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Aaron Bentley
  • Date: 2008-04-15 04:29:44 UTC
  • mto: This revision was merged to the branch mainline in revision 3371.
  • Revision ID: aaron@aaronbentley.com-20080415042944-2o3o664x26507hej
PEP8 fix

Show diffs side-by-side

added added

removed removed

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