/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Jelmer Vernooij
  • Date: 2010-01-20 23:26:31 UTC
  • mto: This revision was merged to the branch mainline in revision 4977.
  • Revision ID: jelmer@samba.org-20100120232631-b9mz0z55712eaxfa
https://launchpad.net/bugs/295611
Cope with ghosts in 'bzr diff'

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