31
31
from bzrlib import (
33
branch as _mod_branch,
42
from bzrlib.smart import (
43
branch as smart_branch,
45
repository as smart_repo,
46
packrepository as smart_packrepo,
51
from bzrlib.tests import test_server
52
from bzrlib.transport import (
39
from bzrlib.branch import Branch, BranchReferenceFormat
40
import bzrlib.smart.branch
41
import bzrlib.smart.bzrdir, bzrlib.smart.bzrdir as smart_dir
42
import bzrlib.smart.packrepository
43
import bzrlib.smart.repository
44
from bzrlib.smart.request import (
45
FailedSmartServerResponse,
48
SuccessfulSmartServerResponse,
50
from bzrlib.tests import (
53
from bzrlib.transport import chroot, get_transport
54
from bzrlib.util import bencode
58
57
def load_tests(standard_tests, module, loader):
59
58
"""Multiply tests version and protocol consistency."""
60
59
# FindRepository tests.
60
bzrdir_mod = bzrlib.smart.bzrdir
62
62
("find_repository", {
63
"_request_class": smart_dir.SmartServerRequestFindRepositoryV1}),
63
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV1}),
64
64
("find_repositoryV2", {
65
"_request_class": smart_dir.SmartServerRequestFindRepositoryV2}),
65
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV2}),
66
66
("find_repositoryV3", {
67
"_request_class": smart_dir.SmartServerRequestFindRepositoryV3}),
67
"_request_class":bzrdir_mod.SmartServerRequestFindRepositoryV3}),
69
to_adapt, result = tests.split_suite_by_re(standard_tests,
69
to_adapt, result = split_suite_by_re(standard_tests,
70
70
"TestSmartServerRequestFindRepository")
71
v2_only, v1_and_2 = tests.split_suite_by_re(to_adapt,
71
v2_only, v1_and_2 = split_suite_by_re(to_adapt,
73
73
tests.multiply_tests(v1_and_2, scenarios, result)
74
74
# The first scenario is only applicable to v1 protocols, it is deleted
106
106
self.transport_server = self.make_transport_server
108
108
def make_transport_server(self):
109
return test_server.SmartTCPServer_for_testing('-' + self.id())
109
return smart.server.SmartTCPServer_for_testing('-' + self.id())
111
111
def get_smart_medium(self):
112
112
"""Get a smart medium to use in tests."""
113
113
return self.get_transport().get_smart_medium()
116
class TestByteStreamToStream(tests.TestCase):
118
def test_repeated_substreams_same_kind_are_one_stream(self):
119
# Make a stream - an iterable of bytestrings.
120
stream = [('text', [versionedfile.FulltextContentFactory(('k1',), None,
121
None, 'foo')]),('text', [
122
versionedfile.FulltextContentFactory(('k2',), None, None, 'bar')])]
123
fmt = bzrdir.format_registry.get('pack-0.92')().repository_format
124
bytes = smart_repo._stream_to_byte_stream(stream, fmt)
126
# Iterate the resulting iterable; checking that we get only one stream
128
fmt, stream = smart_repo._byte_stream_to_stream(bytes)
129
for kind, substream in stream:
130
streams.append((kind, list(substream)))
131
self.assertLength(1, streams)
132
self.assertLength(2, streams[0][1])
135
116
class TestSmartServerResponse(tests.TestCase):
137
118
def test__eq__(self):
138
self.assertEqual(smart_req.SmartServerResponse(('ok', )),
139
smart_req.SmartServerResponse(('ok', )))
140
self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'body'),
141
smart_req.SmartServerResponse(('ok', ), 'body'))
142
self.assertNotEqual(smart_req.SmartServerResponse(('ok', )),
143
smart_req.SmartServerResponse(('notok', )))
144
self.assertNotEqual(smart_req.SmartServerResponse(('ok', ), 'body'),
145
smart_req.SmartServerResponse(('ok', )))
119
self.assertEqual(SmartServerResponse(('ok', )),
120
SmartServerResponse(('ok', )))
121
self.assertEqual(SmartServerResponse(('ok', ), 'body'),
122
SmartServerResponse(('ok', ), 'body'))
123
self.assertNotEqual(SmartServerResponse(('ok', )),
124
SmartServerResponse(('notok', )))
125
self.assertNotEqual(SmartServerResponse(('ok', ), 'body'),
126
SmartServerResponse(('ok', )))
146
127
self.assertNotEqual(None,
147
smart_req.SmartServerResponse(('ok', )))
128
SmartServerResponse(('ok', )))
149
130
def test__str__(self):
150
131
"""SmartServerResponses can be stringified."""
151
132
self.assertEqual(
152
133
"<SuccessfulSmartServerResponse args=('args',) body='body'>",
153
str(smart_req.SuccessfulSmartServerResponse(('args',), 'body')))
134
str(SuccessfulSmartServerResponse(('args',), 'body')))
154
135
self.assertEqual(
155
136
"<FailedSmartServerResponse args=('args',) body='body'>",
156
str(smart_req.FailedSmartServerResponse(('args',), 'body')))
137
str(FailedSmartServerResponse(('args',), 'body')))
159
140
class TestSmartServerRequest(tests.TestCaseWithMemoryTransport):
161
142
def test_translate_client_path(self):
162
143
transport = self.get_transport()
163
request = smart_req.SmartServerRequest(transport, 'foo/')
144
request = SmartServerRequest(transport, 'foo/')
164
145
self.assertEqual('./', request.translate_client_path('foo/'))
165
146
self.assertRaises(
166
147
errors.InvalidURLJoin, request.translate_client_path, 'foo/..')
201
170
local_result = dir.cloning_metadir()
202
171
request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
203
172
request = request_class(backing)
204
expected = smart_req.SuccessfulSmartServerResponse(
173
expected = SuccessfulSmartServerResponse(
205
174
(local_result.network_name(),
206
175
local_result.repository_format.network_name(),
207
176
('branch', local_result.get_branch_format().network_name())))
208
177
self.assertEqual(expected, request.execute('', 'False'))
210
179
def test_cloning_metadir_reference(self):
211
"""The request fails when bzrdir contains a branch reference."""
180
"""The request works when bzrdir contains a branch reference."""
212
181
backing = self.get_transport()
213
182
referenced_branch = self.make_branch('referenced')
214
183
dir = self.make_bzrdir('.')
215
184
local_result = dir.cloning_metadir()
216
reference = _mod_branch.BranchReferenceFormat().initialize(
217
dir, target_branch=referenced_branch)
218
reference_url = _mod_branch.BranchReferenceFormat().get_reference(dir)
185
reference = BranchReferenceFormat().initialize(dir, referenced_branch)
186
reference_url = BranchReferenceFormat().get_reference(dir)
219
187
# The server shouldn't try to follow the branch reference, so it's fine
220
188
# if the referenced branch isn't reachable.
221
189
backing.rename('referenced', 'moved')
222
190
request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
223
191
request = request_class(backing)
224
expected = smart_req.FailedSmartServerResponse(('BranchReference',))
192
expected = SuccessfulSmartServerResponse(
193
(local_result.network_name(),
194
local_result.repository_format.network_name(),
195
('ref', reference_url)))
225
196
self.assertEqual(expected, request.execute('', 'False'))
282
if repo._format.supports_external_lookups:
286
if (smart_dir.SmartServerRequestFindRepositoryV3 ==
253
if (smart.bzrdir.SmartServerRequestFindRepositoryV3 ==
287
254
self._request_class):
288
return smart_req.SuccessfulSmartServerResponse(
289
('ok', '', rich_root, subtrees, external,
255
return SuccessfulSmartServerResponse(
256
('ok', '', rich_root, subtrees, 'no',
290
257
repo._format.network_name()))
291
elif (smart_dir.SmartServerRequestFindRepositoryV2 ==
258
elif (smart.bzrdir.SmartServerRequestFindRepositoryV2 ==
292
259
self._request_class):
293
260
# All tests so far are on formats, and for non-external
295
return smart_req.SuccessfulSmartServerResponse(
296
('ok', '', rich_root, subtrees, external))
262
return SuccessfulSmartServerResponse(
263
('ok', '', rich_root, subtrees, 'no'))
298
return smart_req.SuccessfulSmartServerResponse(
299
('ok', '', rich_root, subtrees))
265
return SuccessfulSmartServerResponse(('ok', '', rich_root, subtrees))
301
267
def test_shared_repository(self):
302
268
"""When there is a shared repository, we get 'ok', 'relpath-to-repo'."""
330
293
"""Test for the supports_external_lookups attribute."""
331
294
backing = self.get_transport()
332
295
request = self._request_class(backing)
333
result = self._make_repository_and_result(
334
format='dirstate-with-subtree')
296
result = self._make_repository_and_result(format='dirstate-with-subtree')
335
297
# check the test will be valid
336
298
self.assertEqual('no', result.args[4])
337
299
self.assertEqual(result, request.execute(''))
340
class TestSmartServerBzrDirRequestGetConfigFile(
341
tests.TestCaseWithMemoryTransport):
342
"""Tests for BzrDir.get_config_file."""
344
def test_present(self):
345
backing = self.get_transport()
346
dir = self.make_bzrdir('.')
347
dir.get_config().set_default_stack_on("/")
348
local_result = dir._get_config()._get_config_file().read()
349
request_class = smart_dir.SmartServerBzrDirRequestConfigFile
350
request = request_class(backing)
351
expected = smart_req.SuccessfulSmartServerResponse((), local_result)
352
self.assertEqual(expected, request.execute(''))
354
def test_missing(self):
355
backing = self.get_transport()
356
dir = self.make_bzrdir('.')
357
request_class = smart_dir.SmartServerBzrDirRequestConfigFile
358
request = request_class(backing)
359
expected = smart_req.SuccessfulSmartServerResponse((), '')
360
self.assertEqual(expected, request.execute(''))
363
302
class TestSmartServerRequestInitializeBzrDir(tests.TestCaseWithMemoryTransport):
365
304
def test_empty_dir(self):
366
305
"""Initializing an empty dir should succeed and do it."""
367
306
backing = self.get_transport()
368
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
369
self.assertEqual(smart_req.SmartServerResponse(('ok', )),
307
request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
308
self.assertEqual(SmartServerResponse(('ok', )),
370
309
request.execute(''))
371
310
made_dir = bzrdir.BzrDir.open_from_transport(backing)
372
311
# no branch, tree or repository is expected with the current
378
317
def test_missing_dir(self):
379
318
"""Initializing a missing directory should fail like the bzrdir api."""
380
319
backing = self.get_transport()
381
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
320
request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
382
321
self.assertRaises(errors.NoSuchFile,
383
322
request.execute, 'subdir')
385
324
def test_initialized_dir(self):
386
325
"""Initializing an extant bzrdir should fail like the bzrdir api."""
387
326
backing = self.get_transport()
388
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
327
request = smart.bzrdir.SmartServerRequestInitializeBzrDir(backing)
389
328
self.make_bzrdir('subdir')
390
329
self.assertRaises(errors.FileExists,
391
330
request.execute, 'subdir')
394
class TestSmartServerRequestBzrDirInitializeEx(
395
tests.TestCaseWithMemoryTransport):
396
"""Basic tests for BzrDir.initialize_ex_1.16 in the smart server.
398
The main unit tests in test_bzrdir exercise the API comprehensively.
401
def test_empty_dir(self):
402
"""Initializing an empty dir should succeed and do it."""
403
backing = self.get_transport()
404
name = self.make_bzrdir('reference')._format.network_name()
405
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
407
smart_req.SmartServerResponse(('', '', '', '', '', '', name,
408
'False', '', '', '')),
409
request.execute(name, '', 'True', 'False', 'False', '', '', '', '',
411
made_dir = bzrdir.BzrDir.open_from_transport(backing)
412
# no branch, tree or repository is expected with the current
414
self.assertRaises(errors.NoWorkingTree, made_dir.open_workingtree)
415
self.assertRaises(errors.NotBranchError, made_dir.open_branch)
416
self.assertRaises(errors.NoRepositoryPresent, made_dir.open_repository)
418
def test_missing_dir(self):
419
"""Initializing a missing directory should fail like the bzrdir api."""
420
backing = self.get_transport()
421
name = self.make_bzrdir('reference')._format.network_name()
422
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
423
self.assertRaises(errors.NoSuchFile, request.execute, name,
424
'subdir/dir', 'False', 'False', 'False', '', '', '', '', 'False')
426
def test_initialized_dir(self):
427
"""Initializing an extant directory should fail like the bzrdir api."""
428
backing = self.get_transport()
429
name = self.make_bzrdir('reference')._format.network_name()
430
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
431
self.make_bzrdir('subdir')
432
self.assertRaises(errors.FileExists, request.execute, name, 'subdir',
433
'False', 'False', 'False', '', '', '', '', 'False')
436
class TestSmartServerRequestOpenBzrDir(tests.TestCaseWithMemoryTransport):
438
def test_no_directory(self):
439
backing = self.get_transport()
440
request = smart_dir.SmartServerRequestOpenBzrDir(backing)
441
self.assertEqual(smart_req.SmartServerResponse(('no', )),
442
request.execute('does-not-exist'))
444
def test_empty_directory(self):
445
backing = self.get_transport()
446
backing.mkdir('empty')
447
request = smart_dir.SmartServerRequestOpenBzrDir(backing)
448
self.assertEqual(smart_req.SmartServerResponse(('no', )),
449
request.execute('empty'))
451
def test_outside_root_client_path(self):
452
backing = self.get_transport()
453
request = smart_dir.SmartServerRequestOpenBzrDir(backing,
454
root_client_path='root')
455
self.assertEqual(smart_req.SmartServerResponse(('no', )),
456
request.execute('not-root'))
459
class TestSmartServerRequestOpenBzrDir_2_1(tests.TestCaseWithMemoryTransport):
461
def test_no_directory(self):
462
backing = self.get_transport()
463
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
464
self.assertEqual(smart_req.SmartServerResponse(('no', )),
465
request.execute('does-not-exist'))
467
def test_empty_directory(self):
468
backing = self.get_transport()
469
backing.mkdir('empty')
470
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
471
self.assertEqual(smart_req.SmartServerResponse(('no', )),
472
request.execute('empty'))
474
def test_present_without_workingtree(self):
475
backing = self.get_transport()
476
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
477
self.make_bzrdir('.')
478
self.assertEqual(smart_req.SmartServerResponse(('yes', 'no')),
481
def test_outside_root_client_path(self):
482
backing = self.get_transport()
483
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing,
484
root_client_path='root')
485
self.assertEqual(smart_req.SmartServerResponse(('no',)),
486
request.execute('not-root'))
489
class TestSmartServerRequestOpenBzrDir_2_1_disk(TestCaseWithChrootedTransport):
491
def test_present_with_workingtree(self):
492
self.vfs_transport_factory = test_server.LocalURLServer
493
backing = self.get_transport()
494
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
495
bd = self.make_bzrdir('.')
496
bd.create_repository()
498
bd.create_workingtree()
499
self.assertEqual(smart_req.SmartServerResponse(('yes', 'yes')),
503
333
class TestSmartServerRequestOpenBranch(TestCaseWithChrootedTransport):
505
335
def test_no_branch(self):
506
336
"""When there is no branch, ('nobranch', ) is returned."""
507
337
backing = self.get_transport()
508
request = smart_dir.SmartServerRequestOpenBranch(backing)
338
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
509
339
self.make_bzrdir('.')
510
self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
340
self.assertEqual(SmartServerResponse(('nobranch', )),
511
341
request.execute(''))
513
343
def test_branch(self):
514
344
"""When there is a branch, 'ok' is returned."""
515
345
backing = self.get_transport()
516
request = smart_dir.SmartServerRequestOpenBranch(backing)
346
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
517
347
self.make_branch('.')
518
self.assertEqual(smart_req.SmartServerResponse(('ok', '')),
348
self.assertEqual(SmartServerResponse(('ok', '')),
519
349
request.execute(''))
521
351
def test_branch_reference(self):
522
352
"""When there is a branch reference, the reference URL is returned."""
523
self.vfs_transport_factory = test_server.LocalURLServer
524
353
backing = self.get_transport()
525
request = smart_dir.SmartServerRequestOpenBranch(backing)
354
request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
526
355
branch = self.make_branch('branch')
527
356
checkout = branch.create_checkout('reference',lightweight=True)
528
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
357
reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
530
358
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
531
self.assertEqual(smart_req.SmartServerResponse(('ok', reference_url)),
359
self.assertEqual(SmartServerResponse(('ok', reference_url)),
532
360
request.execute('reference'))
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',)),
543
363
class TestSmartServerRequestOpenBranchV2(TestCaseWithChrootedTransport):
546
366
"""When there is no branch, ('nobranch', ) is returned."""
547
367
backing = self.get_transport()
548
368
self.make_bzrdir('.')
549
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
550
self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
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)),
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(
571
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
572
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
573
('ref', reference_url)),
574
request.execute('reference'))
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)
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)
588
response = request.execute('feature')
590
request.teardown_jail()
591
expected_format = feature._format.network_name()
592
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
593
('branch', expected_format)),
595
self.assertLength(1, opened_branches)
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',)),
606
class TestSmartServerRequestOpenBranchV3(TestCaseWithChrootedTransport):
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',)),
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)),
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(
634
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
635
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
636
('ref', reference_url)),
637
request.execute('reference'))
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)
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)
651
response = request.execute('feature')
653
request.teardown_jail()
654
expected_format = feature._format.network_name()
655
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
656
('branch', expected_format)),
658
self.assertLength(1, opened_branches)
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')),
369
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
370
self.assertEqual(SmartServerResponse(('nobranch', )),
373
def test_branch(self):
374
"""When there is a branch, 'ok' is returned."""
375
backing = self.get_transport()
376
expected = self.make_branch('.')._format.network_name()
377
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
378
self.assertEqual(SuccessfulSmartServerResponse(('branch', expected)),
381
def test_branch_reference(self):
382
"""When there is a branch reference, the reference URL is returned."""
383
backing = self.get_transport()
384
request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
385
branch = self.make_branch('branch')
386
checkout = branch.create_checkout('reference',lightweight=True)
387
reference_url = BranchReferenceFormat().get_reference(checkout.bzrdir)
388
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
389
self.assertEqual(SuccessfulSmartServerResponse(('ref', reference_url)),
390
request.execute('reference'))
670
393
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
705
428
def test_branch_reference(self):
706
429
"""When there is a branch reference, NotBranchError is raised."""
707
430
backing = self.get_transport()
708
request = smart_branch.SmartServerBranchRequest(backing)
431
request = smart.branch.SmartServerBranchRequest(backing)
709
432
branch = self.make_branch('branch')
710
433
checkout = branch.create_checkout('reference',lightweight=True)
711
434
self.assertRaises(errors.NotBranchError,
712
435
request.execute, 'checkout')
715
class TestSmartServerBranchRequestLastRevisionInfo(
716
tests.TestCaseWithMemoryTransport):
438
class TestSmartServerBranchRequestLastRevisionInfo(tests.TestCaseWithMemoryTransport):
718
440
def test_empty(self):
719
441
"""For an empty branch, the result is ('ok', '0', 'null:')."""
720
442
backing = self.get_transport()
721
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
443
request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
722
444
self.make_branch('.')
723
self.assertEqual(smart_req.SmartServerResponse(('ok', '0', 'null:')),
445
self.assertEqual(SmartServerResponse(('ok', '0', 'null:')),
724
446
request.execute(''))
726
448
def test_not_empty(self):
727
449
"""For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
728
450
backing = self.get_transport()
729
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(backing)
451
request = smart.branch.SmartServerBranchRequestLastRevisionInfo(backing)
730
452
tree = self.make_branch_and_memory_tree('.')
731
453
tree.lock_write()
757
478
# branch.control_files.get('branch.conf') for now - in the future it may
758
479
# perform more complex processing.
759
480
backing = self.get_transport()
760
request = smart_branch.SmartServerBranchGetConfigFile(backing)
481
request = smart.branch.SmartServerBranchGetConfigFile(backing)
761
482
branch = self.make_branch('.')
762
483
branch._transport.put_bytes('branch.conf', 'foo bar baz')
763
self.assertEqual(smart_req.SmartServerResponse(('ok', ), 'foo bar baz'),
484
self.assertEqual(SmartServerResponse(('ok', ), 'foo bar baz'),
764
485
request.execute(''))
767
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
769
def get_lock_tokens(self, branch):
770
branch_token = branch.lock_write().branch_token
771
repo_token = branch.repository.lock_write().repository_token
772
branch.repository.unlock()
773
return branch_token, repo_token
776
class TestSmartServerBranchRequestSetConfigOption(TestLockedBranch):
778
def test_value_name(self):
779
branch = self.make_branch('.')
780
request = smart_branch.SmartServerBranchRequestSetConfigOption(
781
branch.bzrdir.root_transport)
782
branch_token, repo_token = self.get_lock_tokens(branch)
783
config = branch._get_config()
784
result = request.execute('', branch_token, repo_token, 'bar', 'foo',
786
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
787
self.assertEqual('bar', config.get_option('foo'))
791
def test_value_name_section(self):
792
branch = self.make_branch('.')
793
request = smart_branch.SmartServerBranchRequestSetConfigOption(
794
branch.bzrdir.root_transport)
795
branch_token, repo_token = self.get_lock_tokens(branch)
796
config = branch._get_config()
797
result = request.execute('', branch_token, repo_token, 'bar', 'foo',
799
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
800
self.assertEqual('bar', config.get_option('foo', 'gam'))
805
class TestSmartServerBranchRequestSetConfigOptionDict(TestLockedBranch):
808
TestLockedBranch.setUp(self)
809
# A dict with non-ascii keys and values to exercise unicode
811
self.encoded_value_dict = (
812
'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde')
814
'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
816
def test_value_name(self):
817
branch = self.make_branch('.')
818
request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
819
branch.bzrdir.root_transport)
820
branch_token, repo_token = self.get_lock_tokens(branch)
821
config = branch._get_config()
822
result = request.execute('', branch_token, repo_token,
823
self.encoded_value_dict, 'foo', '')
824
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
825
self.assertEqual(self.value_dict, config.get_option('foo'))
829
def test_value_name_section(self):
830
branch = self.make_branch('.')
831
request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
832
branch.bzrdir.root_transport)
833
branch_token, repo_token = self.get_lock_tokens(branch)
834
config = branch._get_config()
835
result = request.execute('', branch_token, repo_token,
836
self.encoded_value_dict, 'foo', 'gam')
837
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
838
self.assertEqual(self.value_dict, config.get_option('foo', 'gam'))
843
class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):
844
# Only called when the branch format and tags match [yay factory
845
# methods] so only need to test straight forward cases.
847
def test_set_bytes(self):
848
base_branch = self.make_branch('base')
849
tag_bytes = base_branch._get_tags_bytes()
850
# get_lock_tokens takes out a lock.
851
branch_token, repo_token = self.get_lock_tokens(base_branch)
852
request = smart_branch.SmartServerBranchSetTagsBytes(
853
self.get_transport())
854
response = request.execute('base', branch_token, repo_token)
855
self.assertEqual(None, response)
856
response = request.do_chunk(tag_bytes)
857
self.assertEqual(None, response)
858
response = request.do_end()
860
smart_req.SuccessfulSmartServerResponse(()), response)
863
def test_lock_failed(self):
864
base_branch = self.make_branch('base')
865
base_branch.lock_write()
866
tag_bytes = base_branch._get_tags_bytes()
867
request = smart_branch.SmartServerBranchSetTagsBytes(
868
self.get_transport())
869
self.assertRaises(errors.TokenMismatch, request.execute,
870
'base', 'wrong token', 'wrong token')
871
# The request handler will keep processing the message parts, so even
872
# if the request fails immediately do_chunk and do_end are still
874
request.do_chunk(tag_bytes)
880
class SetLastRevisionTestBase(TestLockedBranch):
488
class SetLastRevisionTestBase(tests.TestCaseWithMemoryTransport):
881
489
"""Base test case for verbs that implement set_last_revision."""
1097
708
def test_get_parent_none(self):
1098
709
base_branch = self.make_branch('base')
1099
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
710
request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1100
711
response = request.execute('base')
1101
712
self.assertEquals(
1102
smart_req.SuccessfulSmartServerResponse(('',)), response)
713
SuccessfulSmartServerResponse(('',)), response)
1104
715
def test_get_parent_something(self):
1105
716
base_branch = self.make_branch('base')
1106
717
base_branch.set_parent(self.get_url('foo'))
1107
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
718
request = smart.branch.SmartServerBranchGetParent(self.get_transport())
1108
719
response = request.execute('base')
1109
720
self.assertEquals(
1110
smart_req.SuccessfulSmartServerResponse(("../foo",)),
721
SuccessfulSmartServerResponse(("../foo",)),
1114
class TestSmartServerBranchRequestSetParent(TestLockedBranch):
1116
def test_set_parent_none(self):
1117
branch = self.make_branch('base', format="1.9")
1119
branch._set_parent_location('foo')
1121
request = smart_branch.SmartServerBranchRequestSetParentLocation(
1122
self.get_transport())
1123
branch_token, repo_token = self.get_lock_tokens(branch)
1125
response = request.execute('base', branch_token, repo_token, '')
1128
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1129
self.assertEqual(None, branch.get_parent())
1131
def test_set_parent_something(self):
1132
branch = self.make_branch('base', format="1.9")
1133
request = smart_branch.SmartServerBranchRequestSetParentLocation(
1134
self.get_transport())
1135
branch_token, repo_token = self.get_lock_tokens(branch)
1137
response = request.execute('base', branch_token, repo_token,
1141
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1142
self.assertEqual('http://bar/', branch.get_parent())
1145
class TestSmartServerBranchRequestGetTagsBytes(
1146
tests.TestCaseWithMemoryTransport):
1147
# Only called when the branch format and tags match [yay factory
1148
# methods] so only need to test straight forward cases.
725
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
726
# Only called when the branch format and tags match [yay factory
727
# methods] so only need to test straight forward cases.
1150
729
def test_get_bytes(self):
1151
730
base_branch = self.make_branch('base')
1152
request = smart_branch.SmartServerBranchGetTagsBytes(
731
request = smart.branch.SmartServerBranchGetTagsBytes(
1153
732
self.get_transport())
1154
733
response = request.execute('base')
1155
734
self.assertEquals(
1156
smart_req.SuccessfulSmartServerResponse(('',)), response)
735
SuccessfulSmartServerResponse(('',)), response)
1159
738
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
1163
742
stacked_branch = self.make_branch('stacked', format='1.6')
1164
743
# typically should be relative
1165
744
stacked_branch.set_stacked_on_url('../base')
1166
request = smart_branch.SmartServerBranchRequestGetStackedOnURL(
745
request = smart.branch.SmartServerBranchRequestGetStackedOnURL(
1167
746
self.get_transport())
1168
747
response = request.execute('stacked')
1169
748
self.assertEquals(
1170
smart_req.SmartServerResponse(('ok', '../base')),
749
SmartServerResponse(('ok', '../base')),
1174
class TestSmartServerBranchRequestLockWrite(TestLockedBranch):
753
class TestSmartServerBranchRequestLockWrite(tests.TestCaseWithMemoryTransport):
1176
755
def setUp(self):
1177
756
tests.TestCaseWithMemoryTransport.setUp(self)
1179
758
def test_lock_write_on_unlocked_branch(self):
1180
759
backing = self.get_transport()
1181
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
760
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1182
761
branch = self.make_branch('.', format='knit')
1183
762
repository = branch.repository
1184
763
response = request.execute('')
1185
764
branch_nonce = branch.control_files._lock.peek().get('nonce')
1186
765
repository_nonce = repository.control_files._lock.peek().get('nonce')
1187
self.assertEqual(smart_req.SmartServerResponse(
1188
('ok', branch_nonce, repository_nonce)),
767
SmartServerResponse(('ok', branch_nonce, repository_nonce)),
1190
769
# The branch (and associated repository) is now locked. Verify that
1191
770
# with a new branch object.
1192
771
new_branch = repository.bzrdir.open_branch()
1193
772
self.assertRaises(errors.LockContention, new_branch.lock_write)
1195
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1196
response = request.execute('', branch_nonce, repository_nonce)
1198
774
def test_lock_write_on_locked_branch(self):
1199
775
backing = self.get_transport()
1200
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
776
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1201
777
branch = self.make_branch('.')
1202
branch_token = branch.lock_write().branch_token
1203
779
branch.leave_lock_in_place()
1205
781
response = request.execute('')
1206
782
self.assertEqual(
1207
smart_req.SmartServerResponse(('LockContention',)), response)
1209
branch.lock_write(branch_token)
1210
branch.dont_leave_lock_in_place()
783
SmartServerResponse(('LockContention',)), response)
1213
785
def test_lock_write_with_tokens_on_locked_branch(self):
1214
786
backing = self.get_transport()
1215
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
787
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1216
788
branch = self.make_branch('.', format='knit')
1217
branch_token, repo_token = self.get_lock_tokens(branch)
789
branch_token = branch.lock_write()
790
repo_token = branch.repository.lock_write()
791
branch.repository.unlock()
1218
792
branch.leave_lock_in_place()
1219
793
branch.repository.leave_lock_in_place()
1221
795
response = request.execute('',
1222
796
branch_token, repo_token)
1223
797
self.assertEqual(
1224
smart_req.SmartServerResponse(('ok', branch_token, repo_token)),
1227
branch.repository.lock_write(repo_token)
1228
branch.repository.dont_leave_lock_in_place()
1229
branch.repository.unlock()
1230
branch.lock_write(branch_token)
1231
branch.dont_leave_lock_in_place()
798
SmartServerResponse(('ok', branch_token, repo_token)), response)
1234
800
def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
1235
801
backing = self.get_transport()
1236
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
802
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1237
803
branch = self.make_branch('.', format='knit')
1238
branch_token, repo_token = self.get_lock_tokens(branch)
804
branch_token = branch.lock_write()
805
repo_token = branch.repository.lock_write()
806
branch.repository.unlock()
1239
807
branch.leave_lock_in_place()
1240
808
branch.repository.leave_lock_in_place()
1242
810
response = request.execute('',
1243
811
branch_token+'xxx', repo_token)
1244
812
self.assertEqual(
1245
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1247
branch.repository.lock_write(repo_token)
1248
branch.repository.dont_leave_lock_in_place()
1249
branch.repository.unlock()
1250
branch.lock_write(branch_token)
1251
branch.dont_leave_lock_in_place()
813
SmartServerResponse(('TokenMismatch',)), response)
1254
815
def test_lock_write_on_locked_repo(self):
1255
816
backing = self.get_transport()
1256
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
817
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1257
818
branch = self.make_branch('.', format='knit')
1258
repo = branch.repository
1259
repo_token = repo.lock_write().repository_token
1260
repo.leave_lock_in_place()
819
branch.repository.lock_write()
820
branch.repository.leave_lock_in_place()
821
branch.repository.unlock()
1262
822
response = request.execute('')
1263
823
self.assertEqual(
1264
smart_req.SmartServerResponse(('LockContention',)), response)
1266
repo.lock_write(repo_token)
1267
repo.dont_leave_lock_in_place()
824
SmartServerResponse(('LockContention',)), response)
1270
826
def test_lock_write_on_readonly_transport(self):
1271
827
backing = self.get_readonly_transport()
1272
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
828
request = smart.branch.SmartServerBranchRequestLockWrite(backing)
1273
829
branch = self.make_branch('.')
1274
830
root = self.get_transport().clone('/')
1275
831
path = urlutils.relative_url(root.base, self.get_transport().base)
1308
866
def test_unlock_on_unlocked_branch_unlocked_repo(self):
1309
867
backing = self.get_transport()
1310
request = smart_branch.SmartServerBranchRequestUnlock(backing)
868
request = smart.branch.SmartServerBranchRequestUnlock(backing)
1311
869
branch = self.make_branch('.', format='knit')
1312
870
response = request.execute(
1313
871
'', 'branch token', 'repo token')
1314
872
self.assertEqual(
1315
smart_req.SmartServerResponse(('TokenMismatch',)), response)
873
SmartServerResponse(('TokenMismatch',)), response)
1317
875
def test_unlock_on_unlocked_branch_locked_repo(self):
1318
876
backing = self.get_transport()
1319
request = smart_branch.SmartServerBranchRequestUnlock(backing)
877
request = smart.branch.SmartServerBranchRequestUnlock(backing)
1320
878
branch = self.make_branch('.', format='knit')
1321
879
# Lock the repository.
1322
repo_token = branch.repository.lock_write().repository_token
880
repo_token = branch.repository.lock_write()
1323
881
branch.repository.leave_lock_in_place()
1324
882
branch.repository.unlock()
1325
883
# Issue branch lock_write request on the unlocked branch (with locked
1327
response = request.execute('', 'branch token', repo_token)
885
response = request.execute(
886
'', 'branch token', repo_token)
1328
887
self.assertEqual(
1329
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1331
branch.repository.lock_write(repo_token)
1332
branch.repository.dont_leave_lock_in_place()
1333
branch.repository.unlock()
888
SmartServerResponse(('TokenMismatch',)), response)
1336
891
class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport):
1354
909
def test_trivial_bzipped(self):
1355
910
# This tests that the wire encoding is actually bzipped
1356
911
backing = self.get_transport()
1357
request = smart_repo.SmartServerRepositoryGetParentMap(backing)
912
request = smart.repository.SmartServerRepositoryGetParentMap(backing)
1358
913
tree = self.make_branch_and_memory_tree('.')
1360
915
self.assertEqual(None,
1361
916
request.execute('', 'missing-id'))
1362
# Note that it returns a body that is bzipped.
1364
smart_req.SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
1365
request.do_body('\n\n0\n'))
1367
def test_trivial_include_missing(self):
1368
backing = self.get_transport()
1369
request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1370
tree = self.make_branch_and_memory_tree('.')
1372
self.assertEqual(None,
1373
request.execute('', 'missing-id', 'include-missing:'))
1375
smart_req.SuccessfulSmartServerResponse(('ok', ),
1376
bz2.compress('missing:missing-id')),
1377
request.do_body('\n\n0\n'))
1380
class TestSmartServerRepositoryGetRevisionGraph(
1381
tests.TestCaseWithMemoryTransport):
917
# Note that it returns a body (of '' bzipped).
919
SuccessfulSmartServerResponse(('ok', ), bz2.compress('')),
920
request.do_body('\n\n0\n'))
923
class TestSmartServerRepositoryGetRevisionGraph(tests.TestCaseWithMemoryTransport):
1383
925
def test_none_argument(self):
1384
926
backing = self.get_transport()
1385
request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
927
request = smart.repository.SmartServerRepositoryGetRevisionGraph(backing)
1386
928
tree = self.make_branch_and_memory_tree('.')
1387
929
tree.lock_write()
1425
967
# Note that it still returns body (of zero bytes).
1426
self.assertEqual(smart_req.SmartServerResponse(
1427
('nosuchrevision', 'missingrevision', ), ''),
1428
request.execute('', 'missingrevision'))
1431
class TestSmartServerRepositoryGetRevIdForRevno(
1432
tests.TestCaseWithMemoryTransport):
1434
def test_revno_found(self):
1435
backing = self.get_transport()
1436
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1437
tree = self.make_branch_and_memory_tree('.')
1440
rev1_id_utf8 = u'\xc8'.encode('utf-8')
1441
rev2_id_utf8 = u'\xc9'.encode('utf-8')
1442
tree.commit('1st commit', rev_id=rev1_id_utf8)
1443
tree.commit('2nd commit', rev_id=rev2_id_utf8)
1446
self.assertEqual(smart_req.SmartServerResponse(('ok', rev1_id_utf8)),
1447
request.execute('', 1, (2, rev2_id_utf8)))
1449
def test_known_revid_missing(self):
1450
backing = self.get_transport()
1451
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1452
repo = self.make_repository('.')
1454
smart_req.FailedSmartServerResponse(('nosuchrevision', 'ghost')),
1455
request.execute('', 1, (2, 'ghost')))
1457
def test_history_incomplete(self):
1458
backing = self.get_transport()
1459
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1460
parent = self.make_branch_and_memory_tree('parent', format='1.9')
1462
parent.add([''], ['TREE_ROOT'])
1463
r1 = parent.commit(message='first commit')
1464
r2 = parent.commit(message='second commit')
1466
local = self.make_branch_and_memory_tree('local', format='1.9')
1467
local.branch.pull(parent.branch)
1468
local.set_parent_ids([r2])
1469
r3 = local.commit(message='local commit')
1470
local.branch.create_clone_on_transport(
1471
self.get_transport('stacked'), stacked_on=self.get_url('parent'))
1473
smart_req.SmartServerResponse(('history-incomplete', 2, r2)),
1474
request.execute('stacked', 1, (3, r3)))
969
SmartServerResponse(('nosuchrevision', 'missingrevision', ), ''),
970
request.execute('', 'missingrevision'))
1477
973
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1621
1117
def test_lock_write_on_unlocked_repo(self):
1622
1118
backing = self.get_transport()
1623
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1119
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1624
1120
repository = self.make_repository('.', format='knit')
1625
1121
response = request.execute('')
1626
1122
nonce = repository.control_files._lock.peek().get('nonce')
1627
self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
1123
self.assertEqual(SmartServerResponse(('ok', nonce)), response)
1628
1124
# The repository is now locked. Verify that with a new repository
1630
1126
new_repo = repository.bzrdir.open_repository()
1631
1127
self.assertRaises(errors.LockContention, new_repo.lock_write)
1633
request = smart_repo.SmartServerRepositoryUnlock(backing)
1634
response = request.execute('', nonce)
1636
1129
def test_lock_write_on_locked_repo(self):
1637
1130
backing = self.get_transport()
1638
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1131
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1639
1132
repository = self.make_repository('.', format='knit')
1640
repo_token = repository.lock_write().repository_token
1133
repository.lock_write()
1641
1134
repository.leave_lock_in_place()
1642
1135
repository.unlock()
1643
1136
response = request.execute('')
1644
1137
self.assertEqual(
1645
smart_req.SmartServerResponse(('LockContention',)), response)
1647
repository.lock_write(repo_token)
1648
repository.dont_leave_lock_in_place()
1138
SmartServerResponse(('LockContention',)), response)
1651
1140
def test_lock_write_on_readonly_transport(self):
1652
1141
backing = self.get_readonly_transport()
1653
request = smart_repo.SmartServerRepositoryLockWrite(backing)
1142
request = smart.repository.SmartServerRepositoryLockWrite(backing)
1654
1143
repository = self.make_repository('.', format='knit')
1655
1144
response = request.execute('')
1656
1145
self.assertFalse(response.is_successful())
1669
1158
def test_insert_stream_empty(self):
1670
1159
backing = self.get_transport()
1671
request = smart_repo.SmartServerRepositoryInsertStream(backing)
1160
request = smart.repository.SmartServerRepositoryInsertStream(backing)
1672
1161
repository = self.make_repository('.')
1673
1162
response = request.execute('', '')
1674
1163
self.assertEqual(None, response)
1675
1164
response = request.do_chunk(self.make_empty_byte_stream(repository))
1676
1165
self.assertEqual(None, response)
1677
1166
response = request.do_end()
1678
self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1167
self.assertEqual(SmartServerResponse(('ok', )), response)
1681
1170
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
1683
1172
def test_insert_stream_empty(self):
1684
1173
backing = self.get_transport()
1685
request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1174
request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1687
1176
repository = self.make_repository('.', format='knit')
1688
lock_token = repository.lock_write().repository_token
1177
lock_token = repository.lock_write()
1689
1178
response = request.execute('', '', lock_token)
1690
1179
self.assertEqual(None, response)
1691
1180
response = request.do_chunk(self.make_empty_byte_stream(repository))
1692
1181
self.assertEqual(None, response)
1693
1182
response = request.do_end()
1694
self.assertEqual(smart_req.SmartServerResponse(('ok', )), response)
1183
self.assertEqual(SmartServerResponse(('ok', )), response)
1695
1184
repository.unlock()
1697
1186
def test_insert_stream_with_wrong_lock_token(self):
1698
1187
backing = self.get_transport()
1699
request = smart_repo.SmartServerRepositoryInsertStreamLocked(
1188
request = smart.repository.SmartServerRepositoryInsertStreamLocked(
1701
1190
repository = self.make_repository('.', format='knit')
1702
lock_token = repository.lock_write().repository_token
1191
lock_token = repository.lock_write()
1703
1192
self.assertRaises(
1704
1193
errors.TokenMismatch, request.execute, '', '', 'wrong-token')
1705
1194
repository.unlock()
1729
1218
def test_unlock_on_unlocked_repo(self):
1730
1219
backing = self.get_transport()
1731
request = smart_repo.SmartServerRepositoryUnlock(backing)
1220
request = smart.repository.SmartServerRepositoryUnlock(backing)
1732
1221
repository = self.make_repository('.', format='knit')
1733
1222
response = request.execute('', 'some token')
1734
1223
self.assertEqual(
1735
smart_req.SmartServerResponse(('TokenMismatch',)), response)
1224
SmartServerResponse(('TokenMismatch',)), response)
1738
1227
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
1740
1229
def test_is_readonly_no(self):
1741
1230
backing = self.get_transport()
1742
request = smart_req.SmartServerIsReadonly(backing)
1231
request = smart.request.SmartServerIsReadonly(backing)
1743
1232
response = request.execute()
1744
1233
self.assertEqual(
1745
smart_req.SmartServerResponse(('no',)), response)
1234
SmartServerResponse(('no',)), response)
1747
1236
def test_is_readonly_yes(self):
1748
1237
backing = self.get_readonly_transport()
1749
request = smart_req.SmartServerIsReadonly(backing)
1238
request = smart.request.SmartServerIsReadonly(backing)
1750
1239
response = request.execute()
1751
1240
self.assertEqual(
1752
smart_req.SmartServerResponse(('yes',)), response)
1755
class TestSmartServerRepositorySetMakeWorkingTrees(
1756
tests.TestCaseWithMemoryTransport):
1241
SmartServerResponse(('yes',)), response)
1244
class TestSmartServerRepositorySetMakeWorkingTrees(tests.TestCaseWithMemoryTransport):
1758
1246
def test_set_false(self):
1759
1247
backing = self.get_transport()
1760
1248
repo = self.make_repository('.', shared=True)
1761
1249
repo.set_make_working_trees(True)
1762
request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
1250
request_class = smart.repository.SmartServerRepositorySetMakeWorkingTrees
1763
1251
request = request_class(backing)
1764
self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
1252
self.assertEqual(SuccessfulSmartServerResponse(('ok',)),
1765
1253
request.execute('', 'False'))
1766
1254
repo = repo.bzrdir.open_repository()
1767
1255
self.assertFalse(repo.make_working_trees())
1849
1324
"""All registered request_handlers can be found."""
1850
1325
# If there's a typo in a register_lazy call, this loop will fail with
1851
1326
# an AttributeError.
1852
for key, item in smart_req.request_handlers.iteritems():
1327
for key, item in smart.request.request_handlers.iteritems():
1855
def assertHandlerEqual(self, verb, handler):
1856
self.assertEqual(smart_req.request_handlers.get(verb), handler)
1858
1330
def test_registered_methods(self):
1859
1331
"""Test that known methods are registered to the correct object."""
1860
self.assertHandlerEqual('Branch.get_config_file',
1861
smart_branch.SmartServerBranchGetConfigFile)
1862
self.assertHandlerEqual('Branch.get_parent',
1863
smart_branch.SmartServerBranchGetParent)
1864
self.assertHandlerEqual('Branch.get_tags_bytes',
1865
smart_branch.SmartServerBranchGetTagsBytes)
1866
self.assertHandlerEqual('Branch.lock_write',
1867
smart_branch.SmartServerBranchRequestLockWrite)
1868
self.assertHandlerEqual('Branch.last_revision_info',
1869
smart_branch.SmartServerBranchRequestLastRevisionInfo)
1870
self.assertHandlerEqual('Branch.revision_history',
1871
smart_branch.SmartServerRequestRevisionHistory)
1872
self.assertHandlerEqual('Branch.set_config_option',
1873
smart_branch.SmartServerBranchRequestSetConfigOption)
1874
self.assertHandlerEqual('Branch.set_last_revision',
1875
smart_branch.SmartServerBranchRequestSetLastRevision)
1876
self.assertHandlerEqual('Branch.set_last_revision_info',
1877
smart_branch.SmartServerBranchRequestSetLastRevisionInfo)
1878
self.assertHandlerEqual('Branch.set_last_revision_ex',
1879
smart_branch.SmartServerBranchRequestSetLastRevisionEx)
1880
self.assertHandlerEqual('Branch.set_parent_location',
1881
smart_branch.SmartServerBranchRequestSetParentLocation)
1882
self.assertHandlerEqual('Branch.unlock',
1883
smart_branch.SmartServerBranchRequestUnlock)
1884
self.assertHandlerEqual('BzrDir.find_repository',
1885
smart_dir.SmartServerRequestFindRepositoryV1)
1886
self.assertHandlerEqual('BzrDir.find_repositoryV2',
1887
smart_dir.SmartServerRequestFindRepositoryV2)
1888
self.assertHandlerEqual('BzrDirFormat.initialize',
1889
smart_dir.SmartServerRequestInitializeBzrDir)
1890
self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
1891
smart_dir.SmartServerRequestBzrDirInitializeEx)
1892
self.assertHandlerEqual('BzrDir.cloning_metadir',
1893
smart_dir.SmartServerBzrDirRequestCloningMetaDir)
1894
self.assertHandlerEqual('BzrDir.get_config_file',
1895
smart_dir.SmartServerBzrDirRequestConfigFile)
1896
self.assertHandlerEqual('BzrDir.open_branch',
1897
smart_dir.SmartServerRequestOpenBranch)
1898
self.assertHandlerEqual('BzrDir.open_branchV2',
1899
smart_dir.SmartServerRequestOpenBranchV2)
1900
self.assertHandlerEqual('BzrDir.open_branchV3',
1901
smart_dir.SmartServerRequestOpenBranchV3)
1902
self.assertHandlerEqual('PackRepository.autopack',
1903
smart_packrepo.SmartServerPackRepositoryAutopack)
1904
self.assertHandlerEqual('Repository.gather_stats',
1905
smart_repo.SmartServerRepositoryGatherStats)
1906
self.assertHandlerEqual('Repository.get_parent_map',
1907
smart_repo.SmartServerRepositoryGetParentMap)
1908
self.assertHandlerEqual('Repository.get_rev_id_for_revno',
1909
smart_repo.SmartServerRepositoryGetRevIdForRevno)
1910
self.assertHandlerEqual('Repository.get_revision_graph',
1911
smart_repo.SmartServerRepositoryGetRevisionGraph)
1912
self.assertHandlerEqual('Repository.get_stream',
1913
smart_repo.SmartServerRepositoryGetStream)
1914
self.assertHandlerEqual('Repository.has_revision',
1915
smart_repo.SmartServerRequestHasRevision)
1916
self.assertHandlerEqual('Repository.insert_stream',
1917
smart_repo.SmartServerRepositoryInsertStream)
1918
self.assertHandlerEqual('Repository.insert_stream_locked',
1919
smart_repo.SmartServerRepositoryInsertStreamLocked)
1920
self.assertHandlerEqual('Repository.is_shared',
1921
smart_repo.SmartServerRepositoryIsShared)
1922
self.assertHandlerEqual('Repository.lock_write',
1923
smart_repo.SmartServerRepositoryLockWrite)
1924
self.assertHandlerEqual('Repository.tarball',
1925
smart_repo.SmartServerRepositoryTarball)
1926
self.assertHandlerEqual('Repository.unlock',
1927
smart_repo.SmartServerRepositoryUnlock)
1928
self.assertHandlerEqual('Transport.is_readonly',
1929
smart_req.SmartServerIsReadonly)
1333
smart.request.request_handlers.get('Branch.get_config_file'),
1334
smart.branch.SmartServerBranchGetConfigFile)
1336
smart.request.request_handlers.get('Branch.get_parent'),
1337
smart.branch.SmartServerBranchGetParent)
1339
smart.request.request_handlers.get('Branch.get_tags_bytes'),
1340
smart.branch.SmartServerBranchGetTagsBytes)
1342
smart.request.request_handlers.get('Branch.lock_write'),
1343
smart.branch.SmartServerBranchRequestLockWrite)
1345
smart.request.request_handlers.get('Branch.last_revision_info'),
1346
smart.branch.SmartServerBranchRequestLastRevisionInfo)
1348
smart.request.request_handlers.get('Branch.revision_history'),
1349
smart.branch.SmartServerRequestRevisionHistory)
1351
smart.request.request_handlers.get('Branch.set_last_revision'),
1352
smart.branch.SmartServerBranchRequestSetLastRevision)
1354
smart.request.request_handlers.get('Branch.set_last_revision_info'),
1355
smart.branch.SmartServerBranchRequestSetLastRevisionInfo)
1357
smart.request.request_handlers.get('Branch.unlock'),
1358
smart.branch.SmartServerBranchRequestUnlock)
1360
smart.request.request_handlers.get('BzrDir.find_repository'),
1361
smart.bzrdir.SmartServerRequestFindRepositoryV1)
1363
smart.request.request_handlers.get('BzrDir.find_repositoryV2'),
1364
smart.bzrdir.SmartServerRequestFindRepositoryV2)
1366
smart.request.request_handlers.get('BzrDirFormat.initialize'),
1367
smart.bzrdir.SmartServerRequestInitializeBzrDir)
1369
smart.request.request_handlers.get('BzrDir.cloning_metadir'),
1370
smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
1372
smart.request.request_handlers.get('BzrDir.open_branch'),
1373
smart.bzrdir.SmartServerRequestOpenBranch)
1375
smart.request.request_handlers.get('BzrDir.open_branchV2'),
1376
smart.bzrdir.SmartServerRequestOpenBranchV2)
1378
smart.request.request_handlers.get('PackRepository.autopack'),
1379
smart.packrepository.SmartServerPackRepositoryAutopack)
1381
smart.request.request_handlers.get('Repository.gather_stats'),
1382
smart.repository.SmartServerRepositoryGatherStats)
1384
smart.request.request_handlers.get('Repository.get_parent_map'),
1385
smart.repository.SmartServerRepositoryGetParentMap)
1387
smart.request.request_handlers.get(
1388
'Repository.get_revision_graph'),
1389
smart.repository.SmartServerRepositoryGetRevisionGraph)
1391
smart.request.request_handlers.get('Repository.get_stream'),
1392
smart.repository.SmartServerRepositoryGetStream)
1394
smart.request.request_handlers.get('Repository.has_revision'),
1395
smart.repository.SmartServerRequestHasRevision)
1397
smart.request.request_handlers.get('Repository.insert_stream'),
1398
smart.repository.SmartServerRepositoryInsertStream)
1400
smart.request.request_handlers.get('Repository.insert_stream_locked'),
1401
smart.repository.SmartServerRepositoryInsertStreamLocked)
1403
smart.request.request_handlers.get('Repository.is_shared'),
1404
smart.repository.SmartServerRepositoryIsShared)
1406
smart.request.request_handlers.get('Repository.lock_write'),
1407
smart.repository.SmartServerRepositoryLockWrite)
1409
smart.request.request_handlers.get('Repository.tarball'),
1410
smart.repository.SmartServerRepositoryTarball)
1412
smart.request.request_handlers.get('Repository.unlock'),
1413
smart.repository.SmartServerRepositoryUnlock)
1415
smart.request.request_handlers.get('Transport.is_readonly'),
1416
smart.request.SmartServerIsReadonly)
added
removed
bzrlib/tests/test_smart.py
