← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-01-07 17:02:44 UTC
  • mfrom: (4934.1.14 2.1.0rc1-set-mtime)
  • Revision ID: pqm@pqm.ubuntu.com-20100107170244-3cgdapvuokgf8l42
(jam,
        gz) (bug #488724) Set the mtime of files touched in a TreeTransform.

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
 
    def test_notification_on_branch_from_repository(self):
535
 
        """When there is a repository, the error should return details."""
536
 
        backing = self.get_transport()
537
 
        request = smart_dir.SmartServerRequestOpenBranch(backing)
538
 
        repo = self.make_repository('.')
539
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
540
 
            request.execute(''))
541
 
 
542
527
 
543
528
class TestSmartServerRequestOpenBranchV2(TestCaseWithChrootedTransport):
544
529
 
546
531
        """When there is no branch, ('nobranch', ) is returned."""
547
532
        backing = self.get_transport()
548
533
        self.make_bzrdir('.')
549
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
550
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
551
 
            request.execute(''))
552
 
 
553
 
    def test_branch(self):
554
 
        """When there is a branch, 'ok' is returned."""
555
 
        backing = self.get_transport()
556
 
        expected = self.make_branch('.')._format.network_name()
557
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
558
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
559
 
                ('branch', expected)),
560
 
                         request.execute(''))
561
 
 
562
 
    def test_branch_reference(self):
563
 
        """When there is a branch reference, the reference URL is returned."""
564
 
        self.vfs_transport_factory = test_server.LocalURLServer
565
 
        backing = self.get_transport()
566
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
567
 
        branch = self.make_branch('branch')
568
 
        checkout = branch.create_checkout('reference',lightweight=True)
569
 
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
570
 
            checkout.bzrdir)
571
 
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
572
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
573
 
                ('ref', reference_url)),
574
 
                         request.execute('reference'))
575
 
 
576
 
    def test_stacked_branch(self):
577
 
        """Opening a stacked branch does not open the stacked-on branch."""
578
 
        trunk = self.make_branch('trunk')
579
 
        feature = self.make_branch('feature')
580
 
        feature.set_stacked_on_url(trunk.base)
581
 
        opened_branches = []
582
 
        _mod_branch.Branch.hooks.install_named_hook(
583
 
            'open', opened_branches.append, None)
584
 
        backing = self.get_transport()
585
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
586
 
        request.setup_jail()
587
 
        try:
588
 
            response = request.execute('feature')
589
 
        finally:
590
 
            request.teardown_jail()
591
 
        expected_format = feature._format.network_name()
592
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
593
 
                ('branch', expected_format)),
594
 
                         response)
595
 
        self.assertLength(1, opened_branches)
596
 
 
597
 
    def test_notification_on_branch_from_repository(self):
598
 
        """When there is a repository, the error should return details."""
599
 
        backing = self.get_transport()
600
 
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
601
 
        repo = self.make_repository('.')
602
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
603
 
            request.execute(''))
604
 
 
605
 
 
606
 
class TestSmartServerRequestOpenBranchV3(TestCaseWithChrootedTransport):
607
 
 
608
 
    def test_no_branch(self):
609
 
        """When there is no branch, ('nobranch', ) is returned."""
610
 
        backing = self.get_transport()
611
 
        self.make_bzrdir('.')
612
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
613
 
        self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
614
 
            request.execute(''))
615
 
 
616
 
    def test_branch(self):
617
 
        """When there is a branch, 'ok' is returned."""
618
 
        backing = self.get_transport()
619
 
        expected = self.make_branch('.')._format.network_name()
620
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
621
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
622
 
                ('branch', expected)),
623
 
                         request.execute(''))
624
 
 
625
 
    def test_branch_reference(self):
626
 
        """When there is a branch reference, the reference URL is returned."""
627
 
        self.vfs_transport_factory = test_server.LocalURLServer
628
 
        backing = self.get_transport()
629
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
630
 
        branch = self.make_branch('branch')
631
 
        checkout = branch.create_checkout('reference',lightweight=True)
632
 
        reference_url = _mod_branch.BranchReferenceFormat().get_reference(
633
 
            checkout.bzrdir)
634
 
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
635
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
636
 
                ('ref', reference_url)),
637
 
                         request.execute('reference'))
638
 
 
639
 
    def test_stacked_branch(self):
640
 
        """Opening a stacked branch does not open the stacked-on branch."""
641
 
        trunk = self.make_branch('trunk')
642
 
        feature = self.make_branch('feature')
643
 
        feature.set_stacked_on_url(trunk.base)
644
 
        opened_branches = []
645
 
        _mod_branch.Branch.hooks.install_named_hook(
646
 
            'open', opened_branches.append, None)
647
 
        backing = self.get_transport()
648
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
649
 
        request.setup_jail()
650
 
        try:
651
 
            response = request.execute('feature')
652
 
        finally:
653
 
            request.teardown_jail()
654
 
        expected_format = feature._format.network_name()
655
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(
656
 
                ('branch', expected_format)),
657
 
                         response)
658
 
        self.assertLength(1, opened_branches)
659
 
 
660
 
    def test_notification_on_branch_from_repository(self):
661
 
        """When there is a repository, the error should return details."""
662
 
        backing = self.get_transport()
663
 
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
664
 
        repo = self.make_repository('.')
665
 
        self.assertEqual(smart_req.SmartServerResponse(
666
 
                ('nobranch', 'location is a repository')),
667
 
                         request.execute(''))
 
534
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
535
        self.assertEqual(SmartServerResponse(('nobranch', )),
 
536
            request.execute(''))
 
537
 
 
538
    def test_branch(self):
 
539
        """When there is a branch, 'ok' is returned."""
 
540
        backing = self.get_transport()
 
541
        expected = self.make_branch('.')._format.network_name()
 
542
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
543
        self.assertEqual(SuccessfulSmartServerResponse(('branch', expected)),
 
544
            request.execute(''))
 
545
 
 
546
    def test_branch_reference(self):
 
547
        """When there is a branch reference, the reference URL is returned."""
 
548
        self.vfs_transport_factory = local.LocalURLServer
 
549
        backing = self.get_transport()
 
550
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
551
        branch = self.make_branch('branch')
 
552
        checkout = branch.create_checkout('reference',lightweight=True)
 
553
        reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
 
554
        self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
 
555
        self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
 
556
            request.execute('reference'))
 
557
 
 
558
    def test_stacked_branch(self):
 
559
        """Opening a stacked branch does not open the stacked-on branch."""
 
560
        trunk = self.make_branch('trunk')
 
561
        feature = self.make_branch('feature')
 
562
        feature.set_stacked_on_url(trunk.base)
 
563
        opened_branches = []
 
564
        Branch.hooks.install_named_hook('open', opened_branches.append, None)
 
565
        backing = self.get_transport()
 
566
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
 
567
        request.setup_jail()
 
568
        try:
 
569
            response = request.execute('feature')
 
570
        finally:
 
571
            request.teardown_jail()
 
572
        expected_format = feature._format.network_name()
 
573
        self.assertEqual(
 
574
            SuccessfulSmartServerResponse(('branch', expected_format)),
 
575
            response)
 
576
        self.assertLength(1, opened_branches)
668
577
 
669
578
 
670
579
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
672
581
    def test_empty(self):
673
582
        """For an empty branch, the body is empty."""
674
583
        backing = self.get_transport()
675
 
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
 
584
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
676
585
        self.make_branch('.')
677
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), ''),
 
586
        self.assertEqual(SmartServerResponse(('ok', ), ''),
678
587
            request.execute(''))
679
588
 
680
589
    def test_not_empty(self):
681
590
        """For a non-empty branch, the body is empty."""
682
591
        backing = self.get_transport()
683
 
        request = smart_branch.SmartServerRequestRevisionHistory(backing)
 
592
        request = smart.branch.SmartServerRequestRevisionHistory(backing)
684
593
        tree = self.make_branch_and_memory_tree('.')
685
594
        tree.lock_write()
686
595
        tree.add('')
688
597
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
689
598
        tree.unlock()
690
599
        self.assertEqual(
691
 
            smart_req.SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
 
600
            SmartServerResponse(('ok', ), ('\x00'.join([r1, r2]))),
692
601
            request.execute(''))
693
602
 
694
603
 
697
606
    def test_no_branch(self):
698
607
        """When there is a bzrdir and no branch, NotBranchError is raised."""
699
608
        backing = self.get_transport()
700
 
        request = smart_branch.SmartServerBranchRequest(backing)
 
609
        request = smart.branch.SmartServerBranchRequest(backing)
701
610
        self.make_bzrdir('.')
702
611
        self.assertRaises(errors.NotBranchError,
703
612
            request.execute, '')
705
614
    def test_branch_reference(self):
706
615
        """When there is a branch reference, NotBranchError is raised."""
707
616
        backing = self.get_transport()
708
 
        request = smart_branch.SmartServerBranchRequest(backing)
 
617
        request = smart.branch.SmartServerBranchRequest(backing)
709
618
        branch = self.make_branch('branch')
710
619
        checkout = branch.create_checkout('reference',lightweight=True)
711
620
        self.assertRaises(errors.NotBranchError,
712
621
            request.execute, 'checkout')
713
622
 
714
623
 
715
 
class TestSmartServerBranchRequestLastRevisionInfo(
716
 
    tests.TestCaseWithMemoryTransport):
 
624
class TestSmartServerBranchRequestLastRevisionInfo(tests.TestCaseWithMemoryTransport):
717
625
 
718
626
    def test_empty(self):
719
627
        """For an empty branch, the result is ('ok', '0', 'null:')."""
720
628
        backing = self.get_transport()
721
 
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
629
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
722
630
        self.make_branch('.')
723
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', '0', 'null:')),
 
631
        self.assertEqual(SmartServerResponse(('ok', '0', 'null:')),
724
632
            request.execute(''))
725
633
 
726
634
    def test_not_empty(self):
727
635
        """For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
728
636
        backing = self.get_transport()
729
 
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
 
637
        request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
730
638
        tree = self.make_branch_and_memory_tree('.')
731
639
        tree.lock_write()
732
640
        tree.add('')
735
643
        r2 = tree.commit('2nd commit', rev_id=rev_id_utf8)
736
644
        tree.unlock()
737
645
        self.assertEqual(
738
 
            smart_req.SmartServerResponse(('ok', '2', rev_id_utf8)),
 
646
            SmartServerResponse(('ok', '2', rev_id_utf8)),
739
647
            request.execute(''))
740
648
 
741
649
 
742
 
class TestSmartServerBranchRequestGetConfigFile(
743
 
    tests.TestCaseWithMemoryTransport):
 
650
class TestSmartServerBranchRequestGetConfigFile(tests.TestCaseWithMemoryTransport):
744
651
 
745
652
    def test_default(self):
746
653
        """With no file, we get empty content."""
747
654
        backing = self.get_transport()
748
 
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
 
655
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
749
656
        branch = self.make_branch('.')
750
657
        # there should be no file by default
751
658
        content = ''
752
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), content),
 
659
        self.assertEqual(SmartServerResponse(('ok', ), content),
753
660
            request.execute(''))
754
661
 
755
662
    def test_with_content(self):
757
664
        # branch.control_files.get('branch.conf') for now - in the future it may
758
665
        # perform more complex processing.
759
666
        backing = self.get_transport()
760
 
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
 
667
        request = smart.branch.SmartServerBranchGetConfigFile(backing)
761
668
        branch = self.make_branch('.')
762
669
        branch._transport.put_bytes('branch.conf', 'foo bar baz')
763
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'foo bar baz'),
 
670
        self.assertEqual(SmartServerResponse(('ok', ), 'foo bar baz'),
764
671
            request.execute(''))
765
672
 
766
673
 
777
684
 
778
685
    def test_value_name(self):
779
686
        branch = self.make_branch('.')
780
 
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
 
687
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
781
688
            branch.bzrdir.root_transport)
782
689
        branch_token, repo_token = self.get_lock_tokens(branch)
783
690
        config = branch._get_config()
784
691
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
785
692
            '')
786
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
693
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
787
694
        self.assertEqual('bar', config.get_option('foo'))
788
695
        # Cleanup
789
696
        branch.unlock()
790
697
 
791
698
    def test_value_name_section(self):
792
699
        branch = self.make_branch('.')
793
 
        request = smart_branch.SmartServerBranchRequestSetConfigOption(
 
700
        request = smart.branch.SmartServerBranchRequestSetConfigOption(
794
701
            branch.bzrdir.root_transport)
795
702
        branch_token, repo_token = self.get_lock_tokens(branch)
796
703
        config = branch._get_config()
797
704
        result = request.execute('', branch_token, repo_token, 'bar', 'foo',
798
705
            'gam')
799
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
 
706
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
800
707
        self.assertEqual('bar', config.get_option('foo', 'gam'))
801
708
        # Cleanup
802
709
        branch.unlock()
811
718
        tag_bytes = base_branch._get_tags_bytes()
812
719
        # get_lock_tokens takes out a lock.
813
720
        branch_token, repo_token = self.get_lock_tokens(base_branch)
814
 
        request = smart_branch.SmartServerBranchSetTagsBytes(
 
721
        request = smart.branch.SmartServerBranchSetTagsBytes(
815
722
            self.get_transport())
816
723
        response = request.execute('base', branch_token, repo_token)
817
724
        self.assertEqual(None, response)
819
726
        self.assertEqual(None, response)
820
727
        response = request.do_end()
821
728
        self.assertEquals(
822
 
            smart_req.SuccessfulSmartServerResponse(()), response)
 
729
            SuccessfulSmartServerResponse(()), response)
823
730
        base_branch.unlock()
824
731
 
825
732
    def test_lock_failed(self):
826
733
        base_branch = self.make_branch('base')
827
734
        base_branch.lock_write()
828
735
        tag_bytes = base_branch._get_tags_bytes()
829
 
        request = smart_branch.SmartServerBranchSetTagsBytes(
 
736
        request = smart.branch.SmartServerBranchSetTagsBytes(
830
737
            self.get_transport())
831
738
        self.assertRaises(errors.TokenMismatch, request.execute,
832
739
            'base', 'wrong token', 'wrong token')
863
770
 
864
771
    def assertRequestSucceeds(self, revision_id, revno):
865
772
        response = self.set_last_revision(revision_id, revno)
866
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
867
 
                         response)
 
773
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)), response)
868
774
 
869
775
 
870
776
class TestSetLastRevisionVerbMixin(object):
878
784
        """If the revision_id is not present, the verb returns NoSuchRevision.
879
785
        """
880
786
        revision_id = 'non-existent revision'
881
 
        self.assertEqual(smart_req.FailedSmartServerResponse(('NoSuchRevision',
882
 
                                                              revision_id)),
883
 
                         self.set_last_revision(revision_id, 1))
 
787
        self.assertEqual(
 
788
            FailedSmartServerResponse(('NoSuchRevision', revision_id)),
 
789
            self.set_last_revision(revision_id, 1))
884
790
 
885
791
    def make_tree_with_two_commits(self):
886
792
        self.tree.lock_write()
926
832
        rejection_message = u'rejection message\N{INTERROBANG}'
927
833
        def hook_that_rejects(params):
928
834
            raise errors.TipChangeRejected(rejection_message)
929
 
        _mod_branch.Branch.hooks.install_named_hook(
 
835
        Branch.hooks.install_named_hook(
930
836
            'pre_change_branch_tip', hook_that_rejects, None)
931
837
        self.assertEqual(
932
 
            smart_req.FailedSmartServerResponse(
 
838
            FailedSmartServerResponse(
933
839
                ('TipChangeRejected', rejection_message.encode('utf-8'))),
934
840
            self.set_last_revision('null:', 0))
935
841
 
938
844
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
939
845
    """Tests for Branch.set_last_revision verb."""
940
846
 
941
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevision
 
847
    request_class = smart.branch.SmartServerBranchRequestSetLastRevision
942
848
 
943
849
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
944
850
        return self.request.execute(
949
855
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
950
856
    """Tests for Branch.set_last_revision_info verb."""
951
857
 
952
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionInfo
 
858
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionInfo
953
859
 
954
860
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
955
861
        return self.request.execute(
966
872
        SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
967
873
    """Tests for Branch.set_last_revision_ex verb."""
968
874
 
969
 
    request_class = smart_branch.SmartServerBranchRequestSetLastRevisionEx
 
875
    request_class = smart.branch.SmartServerBranchRequestSetLastRevisionEx
970
876
 
971
877
    def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
972
878
        return self.request.execute(
975
881
    def assertRequestSucceeds(self, revision_id, revno):
976
882
        response = self.set_last_revision(revision_id, revno)
977
883
        self.assertEqual(
978
 
            smart_req.SuccessfulSmartServerResponse(('ok', revno, revision_id)),
 
884
            SuccessfulSmartServerResponse(('ok', revno, revision_id)),
979
885
            response)
980
886
 
981
887
    def test_branch_last_revision_info_rewind(self):
992
898
        response = self.request.execute(
993
899
            '', branch_token, repo_token, rev_id_utf8, 0, 0)
994
900
        self.assertEqual(
995
 
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
 
901
            SuccessfulSmartServerResponse(('ok', 2, 'rev-2')),
996
902
            response)
997
903
        self.assertEqual(
998
904
            (2, 'rev-2'), self.tree.branch.last_revision_info())
1002
908
        response = self.request.execute(
1003
909
            '', branch_token, repo_token, rev_id_utf8, 0, 1)
1004
910
        self.assertEqual(
1005
 
            smart_req.SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
 
911
            SuccessfulSmartServerResponse(('ok', 1, rev_id_utf8)),
1006
912
            response)
1007
913
        self.unlock_branch()
1008
914
        self.assertEqual(
1033
939
        """
1034
940
        self.make_branch_with_divergent_history()
1035
941
        self.assertEqual(
1036
 
            smart_req.FailedSmartServerResponse(('Diverged',)),
 
942
            FailedSmartServerResponse(('Diverged',)),
1037
943
            self.set_last_revision('child-1', 2))
1038
944
        # The branch tip was not changed.
1039
945
        self.assertEqual('child-2', self.tree.branch.last_revision())
1047
953
        response = self.request.execute(
1048
954
            '', branch_token, repo_token, 'child-1', 1, 0)
1049
955
        self.assertEqual(
1050
 
            smart_req.SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
 
956
            SuccessfulSmartServerResponse(('ok', 2, 'child-1')),
1051
957
            response)
1052
958
        self.unlock_branch()
1053
959
        # The branch tip was changed.
1058
964
 
1059
965
    def test_get_parent_none(self):
1060
966
        base_branch = self.make_branch('base')
1061
 
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
 
967
        request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1062
968
        response = request.execute('base')
1063
969
        self.assertEquals(
1064
 
            smart_req.SuccessfulSmartServerResponse(('',)), response)
 
970
            SuccessfulSmartServerResponse(('',)), response)
1065
971
 
1066
972
    def test_get_parent_something(self):
1067
973
        base_branch = self.make_branch('base')
1068
974
        base_branch.set_parent(self.get_url('foo'))
1069
 
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
 
975
        request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1070
976
        response = request.execute('base')
1071
977
        self.assertEquals(
1072
 
            smart_req.SuccessfulSmartServerResponse(("../foo",)),
 
978
            SuccessfulSmartServerResponse(("../foo",)),
1073
979
            response)
1074
980
 
1075
981
 
1080
986
        branch.lock_write()
1081
987
        branch._set_parent_location('foo')
1082
988
        branch.unlock()
1083
 
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
 
989
        request = smart.branch.SmartServerBranchRequestSetParentLocation(
1084
990
            self.get_transport())
1085
991
        branch_token = branch.lock_write()
1086
992
        repo_token = branch.repository.lock_write()
1089
995
        finally:
1090
996
            branch.repository.unlock()
1091
997
            branch.unlock()
1092
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
 
998
        self.assertEqual(SuccessfulSmartServerResponse(()), response)
1093
999
        self.assertEqual(None, branch.get_parent())
1094
1000
 
1095
1001
    def test_set_parent_something(self):
1096
1002
        branch = self.make_branch('base', format="1.9")
1097
 
        request = smart_branch.SmartServerBranchRequestSetParentLocation(
 
1003
        request = smart.branch.SmartServerBranchRequestSetParentLocation(
1098
1004
            self.get_transport())
1099
1005
        branch_token = branch.lock_write()
1100
1006
        repo_token = branch.repository.lock_write()
1104
1010
        finally:
1105
1011
            branch.repository.unlock()
1106
1012
            branch.unlock()
1107
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
 
1013
        self.assertEqual(SuccessfulSmartServerResponse(()), response)
1108
1014
        self.assertEqual('http://bar/', branch.get_parent())
1109
1015
 
1110
1016
 
1111
 
class TestSmartServerBranchRequestGetTagsBytes(
1112
 
    tests.TestCaseWithMemoryTransport):
 
1017
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
1113
1018
    # Only called when the branch format and tags match [yay factory
1114
1019
    # methods] so only need to test straight forward cases.
1115
1020
 
1116
1021
    def test_get_bytes(self):
1117
1022
        base_branch = self.make_branch('base')
1118
 
        request = smart_branch.SmartServerBranchGetTagsBytes(
 
1023
        request = smart.branch.SmartServerBranchGetTagsBytes(
1119
1024
            self.get_transport())
1120
1025
        response = request.execute('base')
1121
1026
        self.assertEquals(
1122
 
            smart_req.SuccessfulSmartServerResponse(('',)), response)
 
1027
            SuccessfulSmartServerResponse(('',)), response)
1123
1028
 
1124
1029
 
1125
1030
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
1129
1034
        stacked_branch = self.make_branch('stacked', format='1.6')
1130
1035
        # typically should be relative
1131
1036
        stacked_branch.set_stacked_on_url('../base')
1132
 
        request = smart_branch.SmartServerBranchRequestGetStackedOnURL(
 
1037
        request = smart.branch.SmartServerBranchRequestGetStackedOnURL(
1133
1038
            self.get_transport())
1134
1039
        response = request.execute('stacked')
1135
1040
        self.assertEquals(
1136
 
            smart_req.SmartServerResponse(('ok', '../base')),
 
1041
            SmartServerResponse(('ok', '../base')),
1137
1042
            response)
1138
1043
 
1139
1044
 
1144
1049
 
1145
1050
    def test_lock_write_on_unlocked_branch(self):
1146
1051
        backing = self.get_transport()
1147
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1052
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1148
1053
        branch = self.make_branch('.', format='knit')
1149
1054
        repository = branch.repository
1150
1055
        response = request.execute('')
1151
1056
        branch_nonce = branch.control_files._lock.peek().get('nonce')
1152
1057
        repository_nonce = repository.control_files._lock.peek().get('nonce')
1153
 
        self.assertEqual(smart_req.SmartServerResponse(
1154
 
                ('ok', branch_nonce, repository_nonce)),
1155
 
                         response)
 
1058
        self.assertEqual(
 
1059
            SmartServerResponse(('ok', branch_nonce, repository_nonce)),
 
1060
            response)
1156
1061
        # The branch (and associated repository) is now locked.  Verify that
1157
1062
        # with a new branch object.
1158
1063
        new_branch = repository.bzrdir.open_branch()
1159
1064
        self.assertRaises(errors.LockContention, new_branch.lock_write)
1160
1065
        # Cleanup
1161
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
1066
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1162
1067
        response = request.execute('', branch_nonce, repository_nonce)
1163
1068
 
1164
1069
    def test_lock_write_on_locked_branch(self):
1165
1070
        backing = self.get_transport()
1166
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1071
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1167
1072
        branch = self.make_branch('.')
1168
1073
        branch_token = branch.lock_write()
1169
1074
        branch.leave_lock_in_place()
1170
1075
        branch.unlock()
1171
1076
        response = request.execute('')
1172
1077
        self.assertEqual(
1173
 
            smart_req.SmartServerResponse(('LockContention',)), response)
 
1078
            SmartServerResponse(('LockContention',)), response)
1174
1079
        # Cleanup
1175
1080
        branch.lock_write(branch_token)
1176
1081
        branch.dont_leave_lock_in_place()
1178
1083
 
1179
1084
    def test_lock_write_with_tokens_on_locked_branch(self):
1180
1085
        backing = self.get_transport()
1181
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1086
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1182
1087
        branch = self.make_branch('.', format='knit')
1183
1088
        branch_token = branch.lock_write()
1184
1089
        repo_token = branch.repository.lock_write()
1189
1094
        response = request.execute('',
1190
1095
                                   branch_token, repo_token)
1191
1096
        self.assertEqual(
1192
 
            smart_req.SmartServerResponse(('ok', branch_token, repo_token)),
1193
 
            response)
 
1097
            SmartServerResponse(('ok', branch_token, repo_token)), response)
1194
1098
        # Cleanup
1195
1099
        branch.repository.lock_write(repo_token)
1196
1100
        branch.repository.dont_leave_lock_in_place()
1201
1105
 
1202
1106
    def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
1203
1107
        backing = self.get_transport()
1204
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1108
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1205
1109
        branch = self.make_branch('.', format='knit')
1206
1110
        branch_token = branch.lock_write()
1207
1111
        repo_token = branch.repository.lock_write()
1212
1116
        response = request.execute('',
1213
1117
                                   branch_token+'xxx', repo_token)
1214
1118
        self.assertEqual(
1215
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1119
            SmartServerResponse(('TokenMismatch',)), response)
1216
1120
        # Cleanup
1217
1121
        branch.repository.lock_write(repo_token)
1218
1122
        branch.repository.dont_leave_lock_in_place()
1223
1127
 
1224
1128
    def test_lock_write_on_locked_repo(self):
1225
1129
        backing = self.get_transport()
1226
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1130
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1227
1131
        branch = self.make_branch('.', format='knit')
1228
1132
        repo = branch.repository
1229
1133
        repo_token = repo.lock_write()
1231
1135
        repo.unlock()
1232
1136
        response = request.execute('')
1233
1137
        self.assertEqual(
1234
 
            smart_req.SmartServerResponse(('LockContention',)), response)
 
1138
            SmartServerResponse(('LockContention',)), response)
1235
1139
        # Cleanup
1236
1140
        repo.lock_write(repo_token)
1237
1141
        repo.dont_leave_lock_in_place()
1239
1143
 
1240
1144
    def test_lock_write_on_readonly_transport(self):
1241
1145
        backing = self.get_readonly_transport()
1242
 
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
 
1146
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1243
1147
        branch = self.make_branch('.')
1244
1148
        root = self.get_transport().clone('/')
1245
1149
        path = urlutils.relative_url(root.base, self.get_transport().base)
1256
1160
 
1257
1161
    def test_unlock_on_locked_branch_and_repo(self):
1258
1162
        backing = self.get_transport()
1259
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
1163
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1260
1164
        branch = self.make_branch('.', format='knit')
1261
1165
        # Lock the branch
1262
1166
        branch_token = branch.lock_write()
1270
1174
        response = request.execute('',
1271
1175
                                   branch_token, repo_token)
1272
1176
        self.assertEqual(
1273
 
            smart_req.SmartServerResponse(('ok',)), response)
 
1177
            SmartServerResponse(('ok',)), response)
1274
1178
        # The branch is now unlocked.  Verify that with a new branch
1275
1179
        # object.
1276
1180
        new_branch = branch.bzrdir.open_branch()
1279
1183
 
1280
1184
    def test_unlock_on_unlocked_branch_unlocked_repo(self):
1281
1185
        backing = self.get_transport()
1282
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
1186
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1283
1187
        branch = self.make_branch('.', format='knit')
1284
1188
        response = request.execute(
1285
1189
            '', 'branch token', 'repo token')
1286
1190
        self.assertEqual(
1287
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1191
            SmartServerResponse(('TokenMismatch',)), response)
1288
1192
 
1289
1193
    def test_unlock_on_unlocked_branch_locked_repo(self):
1290
1194
        backing = self.get_transport()
1291
 
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
 
1195
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
1292
1196
        branch = self.make_branch('.', format='knit')
1293
1197
        # Lock the repository.
1294
1198
        repo_token = branch.repository.lock_write()
1299
1203
        response = request.execute(
1300
1204
            '', 'branch token', repo_token)
1301
1205
        self.assertEqual(
1302
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1206
            SmartServerResponse(('TokenMismatch',)), response)
1303
1207
        # Cleanup
1304
1208
        branch.repository.lock_write(repo_token)
1305
1209
        branch.repository.dont_leave_lock_in_place()
1315
1219
        # its the exact path being looked at and the server is not
1316
1220
        # searching.
1317
1221
        backing = self.get_transport()
1318
 
        request = smart_repo.SmartServerRepositoryRequest(backing)
 
1222
        request = smart.repository.SmartServerRepositoryRequest(backing)
1319
1223
        self.make_repository('.', shared=True)
1320
1224
        self.make_bzrdir('subdir')
1321
1225
        self.assertRaises(errors.NoRepositoryPresent,
1327
1231
    def test_trivial_bzipped(self):
1328
1232
        # This tests that the wire encoding is actually bzipped
1329
1233
        backing = self.get_transport()
1330
 
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
 
1234
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1331
1235
        tree = self.make_branch_and_memory_tree('.')
1332
1236
 
1333
1237
        self.assertEqual(None,
1334
1238
            request.execute('', 'missing-id'))
1335
1239
        # Note that it returns a body that is bzipped.
1336
1240
        self.assertEqual(
1337
 
            smart_req.SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
 
1241
            SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1338
1242
            request.do_body('\n\n0\n'))
1339
1243
 
1340
1244
    def test_trivial_include_missing(self):
1341
1245
        backing = self.get_transport()
1342
 
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
 
1246
        request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1343
1247
        tree = self.make_branch_and_memory_tree('.')
1344
1248
 
1345
1249
        self.assertEqual(None,
1346
1250
            request.execute('', 'missing-id', 'include-missing:'))
1347
1251
        self.assertEqual(
1348
 
            smart_req.SuccessfulSmartServerResponse(('ok', ),
 
1252
            SuccessfulSmartServerResponse(('ok', ),
1349
1253
                bz2.compress('missing:missing-id')),
1350
1254
            request.do_body('\n\n0\n'))
1351
1255
 
1352
1256
 
1353
 
class TestSmartServerRepositoryGetRevisionGraph(
1354
 
    tests.TestCaseWithMemoryTransport):
 
1257
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
1355
1258
 
1356
1259
    def test_none_argument(self):
1357
1260
        backing = self.get_transport()
1358
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1261
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1359
1262
        tree = self.make_branch_and_memory_tree('.')
1360
1263
        tree.lock_write()
1361
1264
        tree.add('')
1370
1273
        response.body = '\n'.join(sorted(response.body.split('\n')))
1371
1274
 
1372
1275
        self.assertEqual(
1373
 
            smart_req.SmartServerResponse(('ok', ), '\n'.join(lines)), response)
 
1276
            SmartServerResponse(('ok', ), '\n'.join(lines)), response)
1374
1277
 
1375
1278
    def test_specific_revision_argument(self):
1376
1279
        backing = self.get_transport()
1377
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1280
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1378
1281
        tree = self.make_branch_and_memory_tree('.')
1379
1282
        tree.lock_write()
1380
1283
        tree.add('')
1383
1286
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1384
1287
        tree.unlock()
1385
1288
 
1386
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), rev_id_utf8),
 
1289
        self.assertEqual(SmartServerResponse(('ok', ), rev_id_utf8),
1387
1290
            request.execute('', rev_id_utf8))
1388
1291
 
1389
1292
    def test_no_such_revision(self):
1390
1293
        backing = self.get_transport()
1391
 
        request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
 
1294
        request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1392
1295
        tree = self.make_branch_and_memory_tree('.')
1393
1296
        tree.lock_write()
1394
1297
        tree.add('')
1396
1299
        tree.unlock()
1397
1300
 
1398
1301
        # 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):
 
1302
        self.assertEqual(
 
1303
            SmartServerResponse(('nosuchrevision', 'missingrevision', ), ''),
 
1304
            request.execute('', 'missingrevision'))
 
1305
 
 
1306
 
 
1307
class TestSmartServerRepositoryGetRevIdForRevno(tests.TestCaseWithMemoryTransport):
1406
1308
 
1407
1309
    def test_revno_found(self):
1408
1310
        backing = self.get_transport()
1409
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
 
1311
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
1410
1312
        tree = self.make_branch_and_memory_tree('.')
1411
1313
        tree.lock_write()
1412
1314
        tree.add('')
1416
1318
        tree.commit('2nd commit', rev_id=rev2_id_utf8)
1417
1319
        tree.unlock()
1418
1320
 
1419
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', rev1_id_utf8)),
 
1321
        self.assertEqual(SmartServerResponse(('ok', rev1_id_utf8)),
1420
1322
            request.execute('', 1, (2, rev2_id_utf8)))
1421
1323
 
1422
1324
    def test_known_revid_missing(self):
1423
1325
        backing = self.get_transport()
1424
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
 
1326
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
1425
1327
        repo = self.make_repository('.')
1426
1328
        self.assertEqual(
1427
 
            smart_req.FailedSmartServerResponse(('nosuchrevision', 'ghost')),
 
1329
            FailedSmartServerResponse(('nosuchrevision', 'ghost')),
1428
1330
            request.execute('', 1, (2, 'ghost')))
1429
1331
 
1430
1332
    def test_history_incomplete(self):
1431
1333
        backing = self.get_transport()
1432
 
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
 
1334
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
1433
1335
        parent = self.make_branch_and_memory_tree('parent', format='1.9')
1434
1336
        parent.lock_write()
1435
1337
        parent.add([''], ['TREE_ROOT'])
1443
1345
        local.branch.create_clone_on_transport(
1444
1346
            self.get_transport('stacked'), stacked_on=self.get_url('parent'))
1445
1347
        self.assertEqual(
1446
 
            smart_req.SmartServerResponse(('history-incomplete', 2, r2)),
 
1348
            SmartServerResponse(('history-incomplete', 2, r2)),
1447
1349
            request.execute('stacked', 1, (3, r3)))
1448
1350
 
1449
1351
 
1462
1364
    def test_ancestry_of(self):
1463
1365
        """The search argument may be a 'ancestry-of' some heads'."""
1464
1366
        backing = self.get_transport()
1465
 
        request = smart_repo.SmartServerRepositoryGetStream(backing)
 
1367
        request = smart.repository.SmartServerRepositoryGetStream(backing)
1466
1368
        repo, r1, r2 = self.make_two_commit_repo()
1467
1369
        fetch_spec = ['ancestry-of', r2]
1468
1370
        lines = '\n'.join(fetch_spec)
1475
1377
    def test_search(self):
1476
1378
        """The search argument may be a 'search' of some explicit keys."""
1477
1379
        backing = self.get_transport()
1478
 
        request = smart_repo.SmartServerRepositoryGetStream(backing)
 
1380
        request = smart.repository.SmartServerRepositoryGetStream(backing)
1479
1381
        repo, r1, r2 = self.make_two_commit_repo()
1480
1382
        fetch_spec = ['search', '%s %s' % (r1, r2), 'null:', '2']
1481
1383
        lines = '\n'.join(fetch_spec)
1491
1393
    def test_missing_revision(self):
1492
1394
        """For a missing revision, ('no', ) is returned."""
1493
1395
        backing = self.get_transport()
1494
 
        request = smart_repo.SmartServerRequestHasRevision(backing)
 
1396
        request = smart.repository.SmartServerRequestHasRevision(backing)
1495
1397
        self.make_repository('.')
1496
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1398
        self.assertEqual(SmartServerResponse(('no', )),
1497
1399
            request.execute('', 'revid'))
1498
1400
 
1499
1401
    def test_present_revision(self):
1500
1402
        """For a present revision, ('yes', ) is returned."""
1501
1403
        backing = self.get_transport()
1502
 
        request = smart_repo.SmartServerRequestHasRevision(backing)
 
1404
        request = smart.repository.SmartServerRequestHasRevision(backing)
1503
1405
        tree = self.make_branch_and_memory_tree('.')
1504
1406
        tree.lock_write()
1505
1407
        tree.add('')
1507
1409
        r1 = tree.commit('a commit', rev_id=rev_id_utf8)
1508
1410
        tree.unlock()
1509
1411
        self.assertTrue(tree.branch.repository.has_revision(rev_id_utf8))
1510
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1412
        self.assertEqual(SmartServerResponse(('yes', )),
1511
1413
            request.execute('', rev_id_utf8))
1512
1414
 
1513
1415
 
1516
1418
    def test_empty_revid(self):
1517
1419
        """With an empty revid, we get only size an number and revisions"""
1518
1420
        backing = self.get_transport()
1519
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1421
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1520
1422
        repository = self.make_repository('.')
1521
1423
        stats = repository.gather_stats()
1522
1424
        expected_body = 'revisions: 0\n'
1523
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1425
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1524
1426
                         request.execute('', '', 'no'))
1525
1427
 
1526
1428
    def test_revid_with_committers(self):
1527
1429
        """For a revid we get more infos."""
1528
1430
        backing = self.get_transport()
1529
1431
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1530
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1432
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1531
1433
        tree = self.make_branch_and_memory_tree('.')
1532
1434
        tree.lock_write()
1533
1435
        tree.add('')
1541
1443
        expected_body = ('firstrev: 123456.200 3600\n'
1542
1444
                         'latestrev: 654321.400 0\n'
1543
1445
                         'revisions: 2\n')
1544
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1446
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1545
1447
                         request.execute('',
1546
1448
                                         rev_id_utf8, 'no'))
1547
1449
 
1549
1451
        """For a revid and requesting committers we get the whole thing."""
1550
1452
        backing = self.get_transport()
1551
1453
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1552
 
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
 
1454
        request = smart.repository.SmartServerRepositoryGatherStats(backing)
1553
1455
        tree = self.make_branch_and_memory_tree('.')
1554
1456
        tree.lock_write()
1555
1457
        tree.add('')
1565
1467
                         'firstrev: 123456.200 3600\n'
1566
1468
                         'latestrev: 654321.400 0\n'
1567
1469
                         'revisions: 2\n')
1568
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), expected_body),
 
1470
        self.assertEqual(SmartServerResponse(('ok', ), expected_body),
1569
1471
                         request.execute('',
1570
1472
                                         rev_id_utf8, 'yes'))
1571
1473
 
1575
1477
    def test_is_shared(self):
1576
1478
        """For a shared repository, ('yes', ) is returned."""
1577
1479
        backing = self.get_transport()
1578
 
        request = smart_repo.SmartServerRepositoryIsShared(backing)
 
1480
        request = smart.repository.SmartServerRepositoryIsShared(backing)
1579
1481
        self.make_repository('.', shared=True)
1580
 
        self.assertEqual(smart_req.SmartServerResponse(('yes', )),
 
1482
        self.assertEqual(SmartServerResponse(('yes', )),
1581
1483
            request.execute('', ))
1582
1484
 
1583
1485
    def test_is_not_shared(self):
1584
1486
        """For a shared repository, ('no', ) is returned."""
1585
1487
        backing = self.get_transport()
1586
 
        request = smart_repo.SmartServerRepositoryIsShared(backing)
 
1488
        request = smart.repository.SmartServerRepositoryIsShared(backing)
1587
1489
        self.make_repository('.', shared=False)
1588
 
        self.assertEqual(smart_req.SmartServerResponse(('no', )),
 
1490
        self.assertEqual(SmartServerResponse(('no', )),
1589
1491
            request.execute('', ))
1590
1492
 
1591
1493
 
1593
1495
 
1594
1496
    def test_lock_write_on_unlocked_repo(self):
1595
1497
        backing = self.get_transport()
1596
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1498
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1597
1499
        repository = self.make_repository('.', format='knit')
1598
1500
        response = request.execute('')
1599
1501
        nonce = repository.control_files._lock.peek().get('nonce')
1600
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
 
1502
        self.assertEqual(SmartServerResponse(('ok', nonce)), response)
1601
1503
        # The repository is now locked.  Verify that with a new repository
1602
1504
        # object.
1603
1505
        new_repo = repository.bzrdir.open_repository()
1604
1506
        self.assertRaises(errors.LockContention, new_repo.lock_write)
1605
1507
        # Cleanup
1606
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1508
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1607
1509
        response = request.execute('', nonce)
1608
1510
 
1609
1511
    def test_lock_write_on_locked_repo(self):
1610
1512
        backing = self.get_transport()
1611
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1513
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1612
1514
        repository = self.make_repository('.', format='knit')
1613
1515
        repo_token = repository.lock_write()
1614
1516
        repository.leave_lock_in_place()
1615
1517
        repository.unlock()
1616
1518
        response = request.execute('')
1617
1519
        self.assertEqual(
1618
 
            smart_req.SmartServerResponse(('LockContention',)), response)
 
1520
            SmartServerResponse(('LockContention',)), response)
1619
1521
        # Cleanup
1620
1522
        repository.lock_write(repo_token)
1621
1523
        repository.dont_leave_lock_in_place()
1623
1525
 
1624
1526
    def test_lock_write_on_readonly_transport(self):
1625
1527
        backing = self.get_readonly_transport()
1626
 
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
 
1528
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1627
1529
        repository = self.make_repository('.', format='knit')
1628
1530
        response = request.execute('')
1629
1531
        self.assertFalse(response.is_successful())
1633
1535
class TestInsertStreamBase(tests.TestCaseWithMemoryTransport):
1634
1536
 
1635
1537
    def make_empty_byte_stream(self, repo):
1636
 
        byte_stream = smart_repo._stream_to_byte_stream([], repo._format)
 
1538
        byte_stream = smart.repository._stream_to_byte_stream([], repo._format)
1637
1539
        return ''.join(byte_stream)
1638
1540
 
1639
1541
 
1641
1543
 
1642
1544
    def test_insert_stream_empty(self):
1643
1545
        backing = self.get_transport()
1644
 
        request = smart_repo.SmartServerRepositoryInsertStream(backing)
 
1546
        request = smart.repository.SmartServerRepositoryInsertStream(backing)
1645
1547
        repository = self.make_repository('.')
1646
1548
        response = request.execute('', '')
1647
1549
        self.assertEqual(None, response)
1648
1550
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1649
1551
        self.assertEqual(None, response)
1650
1552
        response = request.do_end()
1651
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1652
 
 
 
1553
        self.assertEqual(SmartServerResponse(('ok', )), response)
 
1554
        
1653
1555
 
1654
1556
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
1655
1557
 
1656
1558
    def test_insert_stream_empty(self):
1657
1559
        backing = self.get_transport()
1658
 
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
 
1560
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1659
1561
            backing)
1660
1562
        repository = self.make_repository('.', format='knit')
1661
1563
        lock_token = repository.lock_write()
1664
1566
        response = request.do_chunk(self.make_empty_byte_stream(repository))
1665
1567
        self.assertEqual(None, response)
1666
1568
        response = request.do_end()
1667
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
 
1569
        self.assertEqual(SmartServerResponse(('ok', )), response)
1668
1570
        repository.unlock()
1669
1571
 
1670
1572
    def test_insert_stream_with_wrong_lock_token(self):
1671
1573
        backing = self.get_transport()
1672
 
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
 
1574
        request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1673
1575
            backing)
1674
1576
        repository = self.make_repository('.', format='knit')
1675
1577
        lock_token = repository.lock_write()
1685
1587
 
1686
1588
    def test_unlock_on_locked_repo(self):
1687
1589
        backing = self.get_transport()
1688
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1590
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1689
1591
        repository = self.make_repository('.', format='knit')
1690
1592
        token = repository.lock_write()
1691
1593
        repository.leave_lock_in_place()
1692
1594
        repository.unlock()
1693
1595
        response = request.execute('', token)
1694
1596
        self.assertEqual(
1695
 
            smart_req.SmartServerResponse(('ok',)), response)
 
1597
            SmartServerResponse(('ok',)), response)
1696
1598
        # The repository is now unlocked.  Verify that with a new repository
1697
1599
        # object.
1698
1600
        new_repo = repository.bzrdir.open_repository()
1701
1603
 
1702
1604
    def test_unlock_on_unlocked_repo(self):
1703
1605
        backing = self.get_transport()
1704
 
        request = smart_repo.SmartServerRepositoryUnlock(backing)
 
1606
        request = smart.repository.SmartServerRepositoryUnlock(backing)
1705
1607
        repository = self.make_repository('.', format='knit')
1706
1608
        response = request.execute('', 'some token')
1707
1609
        self.assertEqual(
1708
 
            smart_req.SmartServerResponse(('TokenMismatch',)), response)
 
1610
            SmartServerResponse(('TokenMismatch',)), response)
1709
1611
 
1710
1612
 
1711
1613
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1712
1614
 
1713
1615
    def test_is_readonly_no(self):
1714
1616
        backing = self.get_transport()
1715
 
        request = smart_req.SmartServerIsReadonly(backing)
 
1617
        request = smart.request.SmartServerIsReadonly(backing)
1716
1618
        response = request.execute()
1717
1619
        self.assertEqual(
1718
 
            smart_req.SmartServerResponse(('no',)), response)
 
1620
            SmartServerResponse(('no',)), response)
1719
1621
 
1720
1622
    def test_is_readonly_yes(self):
1721
1623
        backing = self.get_readonly_transport()
1722
 
        request = smart_req.SmartServerIsReadonly(backing)
 
1624
        request = smart.request.SmartServerIsReadonly(backing)
1723
1625
        response = request.execute()
1724
1626
        self.assertEqual(
1725
 
            smart_req.SmartServerResponse(('yes',)), response)
1726
 
 
1727
 
 
1728
 
class TestSmartServerRepositorySetMakeWorkingTrees(
1729
 
    tests.TestCaseWithMemoryTransport):
 
1627
            SmartServerResponse(('yes',)), response)
 
1628
 
 
1629
 
 
1630
class TestSmartServerRepositorySetMakeWorkingTrees(tests.TestCaseWithMemoryTransport):
1730
1631
 
1731
1632
    def test_set_false(self):
1732
1633
        backing = self.get_transport()
1733
1634
        repo = self.make_repository('.', shared=True)
1734
1635
        repo.set_make_working_trees(True)
1735
 
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
 
1636
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1736
1637
        request = request_class(backing)
1737
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1638
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1738
1639
            request.execute('', 'False'))
1739
1640
        repo = repo.bzrdir.open_repository()
1740
1641
        self.assertFalse(repo.make_working_trees())
1743
1644
        backing = self.get_transport()
1744
1645
        repo = self.make_repository('.', shared=True)
1745
1646
        repo.set_make_working_trees(False)
1746
 
        request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
 
1647
        request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1747
1648
        request = request_class(backing)
1748
 
        self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
 
1649
        self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1749
1650
            request.execute('', 'True'))
1750
1651
        repo = repo.bzrdir.open_repository()
1751
1652
        self.assertTrue(repo.make_working_trees())
1770
1671
        repo.lock_write()
1771
1672
        self.addCleanup(repo.unlock)
1772
1673
        backing = self.get_transport()
1773
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1674
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1774
1675
            backing)
1775
1676
        response = request.execute('')
1776
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1677
        self.assertEqual(SmartServerResponse(('ok',)), response)
1777
1678
        repo._pack_collection.reload_pack_names()
1778
1679
        self.assertEqual(1, len(repo._pack_collection.names()))
1779
1680
 
1785
1686
        for x in range(9):
1786
1687
            tree.commit('commit %s' % x)
1787
1688
        backing = self.get_transport()
1788
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1689
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1789
1690
            backing)
1790
1691
        response = request.execute('')
1791
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1692
        self.assertEqual(SmartServerResponse(('ok',)), response)
1792
1693
        repo._pack_collection.reload_pack_names()
1793
1694
        self.assertEqual(9, len(repo._pack_collection.names()))
1794
1695
 
1796
1697
        """A request to autopack a non-pack repo is a no-op."""
1797
1698
        repo = self.make_repository('.', format='knit')
1798
1699
        backing = self.get_transport()
1799
 
        request = smart_packrepo.SmartServerPackRepositoryAutopack(
 
1700
        request = smart.packrepository.SmartServerPackRepositoryAutopack(
1800
1701
            backing)
1801
1702
        response = request.execute('')
1802
 
        self.assertEqual(smart_req.SmartServerResponse(('ok',)), response)
 
1703
        self.assertEqual(SmartServerResponse(('ok',)), response)
1803
1704
 
1804
1705
 
1805
1706
class TestSmartServerVfsGet(tests.TestCaseWithMemoryTransport):
1809
1710
        filename = u'foo\N{INTERROBANG}'
1810
1711
        filename_escaped = urlutils.escape(filename)
1811
1712
        backing = self.get_transport()
1812
 
        request = vfs.GetRequest(backing)
 
1713
        request = smart.vfs.GetRequest(backing)
1813
1714
        backing.put_bytes_non_atomic(filename_escaped, 'contents')
1814
 
        self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'contents'),
 
1715
        self.assertEqual(SmartServerResponse(('ok', ), 'contents'),
1815
1716
            request.execute(filename_escaped))
1816
1717
 
1817
1718
 
1822
1723
        """All registered request_handlers can be found."""
1823
1724
        # If there's a typo in a register_lazy call, this loop will fail with
1824
1725
        # an AttributeError.
1825
 
        for key, item in smart_req.request_handlers.iteritems():
 
1726
        for key, item in smart.request.request_handlers.iteritems():
1826
1727
            pass
1827
1728
 
1828
1729
    def assertHandlerEqual(self, verb, handler):
1829
 
        self.assertEqual(smart_req.request_handlers.get(verb), handler)
 
1730
        self.assertEqual(smart.request.request_handlers.get(verb), handler)
1830
1731
 
1831
1732
    def test_registered_methods(self):
1832
1733
        """Test that known methods are registered to the correct object."""
1833
1734
        self.assertHandlerEqual('Branch.get_config_file',
1834
 
            smart_branch.SmartServerBranchGetConfigFile)
 
1735
            smart.branch.SmartServerBranchGetConfigFile)
1835
1736
        self.assertHandlerEqual('Branch.get_parent',
1836
 
            smart_branch.SmartServerBranchGetParent)
 
1737
            smart.branch.SmartServerBranchGetParent)
1837
1738
        self.assertHandlerEqual('Branch.get_tags_bytes',
1838
 
            smart_branch.SmartServerBranchGetTagsBytes)
 
1739
            smart.branch.SmartServerBranchGetTagsBytes)
1839
1740
        self.assertHandlerEqual('Branch.lock_write',
1840
 
            smart_branch.SmartServerBranchRequestLockWrite)
 
1741
            smart.branch.SmartServerBranchRequestLockWrite)
1841
1742
        self.assertHandlerEqual('Branch.last_revision_info',
1842
 
            smart_branch.SmartServerBranchRequestLastRevisionInfo)
 
1743
            smart.branch.SmartServerBranchRequestLastRevisionInfo)
1843
1744
        self.assertHandlerEqual('Branch.revision_history',
1844
 
            smart_branch.SmartServerRequestRevisionHistory)
 
1745
            smart.branch.SmartServerRequestRevisionHistory)
1845
1746
        self.assertHandlerEqual('Branch.set_config_option',
1846
 
            smart_branch.SmartServerBranchRequestSetConfigOption)
 
1747
            smart.branch.SmartServerBranchRequestSetConfigOption)
1847
1748
        self.assertHandlerEqual('Branch.set_last_revision',
1848
 
            smart_branch.SmartServerBranchRequestSetLastRevision)
 
1749
            smart.branch.SmartServerBranchRequestSetLastRevision)
1849
1750
        self.assertHandlerEqual('Branch.set_last_revision_info',
1850
 
            smart_branch.SmartServerBranchRequestSetLastRevisionInfo)
 
1751
            smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
1851
1752
        self.assertHandlerEqual('Branch.set_last_revision_ex',
1852
 
            smart_branch.SmartServerBranchRequestSetLastRevisionEx)
 
1753
            smart.branch.SmartServerBranchRequestSetLastRevisionEx)
1853
1754
        self.assertHandlerEqual('Branch.set_parent_location',
1854
 
            smart_branch.SmartServerBranchRequestSetParentLocation)
 
1755
            smart.branch.SmartServerBranchRequestSetParentLocation)
1855
1756
        self.assertHandlerEqual('Branch.unlock',
1856
 
            smart_branch.SmartServerBranchRequestUnlock)
 
1757
            smart.branch.SmartServerBranchRequestUnlock)
1857
1758
        self.assertHandlerEqual('BzrDir.find_repository',
1858
 
            smart_dir.SmartServerRequestFindRepositoryV1)
 
1759
            smart.bzrdir.SmartServerRequestFindRepositoryV1)
1859
1760
        self.assertHandlerEqual('BzrDir.find_repositoryV2',
1860
 
            smart_dir.SmartServerRequestFindRepositoryV2)
 
1761
            smart.bzrdir.SmartServerRequestFindRepositoryV2)
1861
1762
        self.assertHandlerEqual('BzrDirFormat.initialize',
1862
 
            smart_dir.SmartServerRequestInitializeBzrDir)
 
1763
            smart.bzrdir.SmartServerRequestInitializeBzrDir)
1863
1764
        self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
1864
 
            smart_dir.SmartServerRequestBzrDirInitializeEx)
 
1765
            smart.bzrdir.SmartServerRequestBzrDirInitializeEx)
1865
1766
        self.assertHandlerEqual('BzrDir.cloning_metadir',
1866
 
            smart_dir.SmartServerBzrDirRequestCloningMetaDir)
 
1767
            smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
1867
1768
        self.assertHandlerEqual('BzrDir.get_config_file',
1868
 
            smart_dir.SmartServerBzrDirRequestConfigFile)
 
1769
            smart.bzrdir.SmartServerBzrDirRequestConfigFile)
1869
1770
        self.assertHandlerEqual('BzrDir.open_branch',
1870
 
            smart_dir.SmartServerRequestOpenBranch)
 
1771
            smart.bzrdir.SmartServerRequestOpenBranch)
1871
1772
        self.assertHandlerEqual('BzrDir.open_branchV2',
1872
 
            smart_dir.SmartServerRequestOpenBranchV2)
1873
 
        self.assertHandlerEqual('BzrDir.open_branchV3',
1874
 
            smart_dir.SmartServerRequestOpenBranchV3)
 
1773
            smart.bzrdir.SmartServerRequestOpenBranchV2)
1875
1774
        self.assertHandlerEqual('PackRepository.autopack',
1876
 
            smart_packrepo.SmartServerPackRepositoryAutopack)
 
1775
            smart.packrepository.SmartServerPackRepositoryAutopack)
1877
1776
        self.assertHandlerEqual('Repository.gather_stats',
1878
 
            smart_repo.SmartServerRepositoryGatherStats)
 
1777
            smart.repository.SmartServerRepositoryGatherStats)
1879
1778
        self.assertHandlerEqual('Repository.get_parent_map',
1880
 
            smart_repo.SmartServerRepositoryGetParentMap)
 
1779
            smart.repository.SmartServerRepositoryGetParentMap)
1881
1780
        self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1882
 
            smart_repo.SmartServerRepositoryGetRevIdForRevno)
 
1781
            smart.repository.SmartServerRepositoryGetRevIdForRevno)
1883
1782
        self.assertHandlerEqual('Repository.get_revision_graph',
1884
 
            smart_repo.SmartServerRepositoryGetRevisionGraph)
 
1783
            smart.repository.SmartServerRepositoryGetRevisionGraph)
1885
1784
        self.assertHandlerEqual('Repository.get_stream',
1886
 
            smart_repo.SmartServerRepositoryGetStream)
 
1785
            smart.repository.SmartServerRepositoryGetStream)
1887
1786
        self.assertHandlerEqual('Repository.has_revision',
1888
 
            smart_repo.SmartServerRequestHasRevision)
 
1787
            smart.repository.SmartServerRequestHasRevision)
1889
1788
        self.assertHandlerEqual('Repository.insert_stream',
1890
 
            smart_repo.SmartServerRepositoryInsertStream)
 
1789
            smart.repository.SmartServerRepositoryInsertStream)
1891
1790
        self.assertHandlerEqual('Repository.insert_stream_locked',
1892
 
            smart_repo.SmartServerRepositoryInsertStreamLocked)
 
1791
            smart.repository.SmartServerRepositoryInsertStreamLocked)
1893
1792
        self.assertHandlerEqual('Repository.is_shared',
1894
 
            smart_repo.SmartServerRepositoryIsShared)
 
1793
            smart.repository.SmartServerRepositoryIsShared)
1895
1794
        self.assertHandlerEqual('Repository.lock_write',
1896
 
            smart_repo.SmartServerRepositoryLockWrite)
 
1795
            smart.repository.SmartServerRepositoryLockWrite)
1897
1796
        self.assertHandlerEqual('Repository.tarball',
1898
 
            smart_repo.SmartServerRepositoryTarball)
 
1797
            smart.repository.SmartServerRepositoryTarball)
1899
1798
        self.assertHandlerEqual('Repository.unlock',
1900
 
            smart_repo.SmartServerRepositoryUnlock)
 
1799
            smart.repository.SmartServerRepositoryUnlock)
1901
1800
        self.assertHandlerEqual('Transport.is_readonly',
1902
 
            smart_req.SmartServerIsReadonly)
 
1801
            smart.request.SmartServerIsReadonly)