← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Ian Clatworthy
  • Date: 2009-07-02 08:26:00 UTC
  • mto: (4527.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4529.
  • Revision ID: ian.clatworthy@canonical.com-20090702082600-qwb1evvvfa8ctnye
first draft of a 2.0 Upgrade Guide

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