1
# Copyright (C) 2006-2012, 2016 Canonical Ltd
1
# Copyright (C) 2006-2012 Canonical Ltd
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
32
32
branch as _mod_branch,
40
from breezy.bzr import (
41
branch as _mod_bzrbranch,
45
from breezy.bzr.smart import (
42
from bzrlib.smart import (
46
43
branch as smart_branch,
47
44
bzrdir as smart_dir,
48
45
repository as smart_repo,
54
from breezy.testament import Testament
55
from breezy.tests import test_server
56
from breezy.transport import (
51
from bzrlib.testament import Testament
52
from bzrlib.tests import test_server
53
from bzrlib.transport import (
62
def load_tests(loader, standard_tests, pattern):
59
def load_tests(standard_tests, module, loader):
63
60
"""Multiply tests version and protocol consistency."""
64
61
# FindRepository tests.
122
119
def test_repeated_substreams_same_kind_are_one_stream(self):
123
120
# Make a stream - an iterable of bytestrings.
124
121
stream = [('text', [versionedfile.FulltextContentFactory(('k1',), None,
125
None, 'foo')]), ('text', [
122
None, 'foo')]),('text', [
126
123
versionedfile.FulltextContentFactory(('k2',), None, None, 'bar')])]
127
124
fmt = controldir.format_registry.get('pack-0.92')().repository_format
128
125
bytes = smart_repo._stream_to_byte_stream(stream, fmt)
167
164
request = smart_req.SmartServerRequest(transport, 'foo/')
168
165
self.assertEqual('./', request.translate_client_path('foo/'))
169
166
self.assertRaises(
170
urlutils.InvalidURLJoin, request.translate_client_path, 'foo/..')
167
errors.InvalidURLJoin, request.translate_client_path, 'foo/..')
171
168
self.assertRaises(
172
169
errors.PathNotChild, request.translate_client_path, '/')
173
170
self.assertRaises(
201
198
def test_cloning_metadir(self):
202
199
"""When there is a bzrdir present, the call succeeds."""
203
200
backing = self.get_transport()
204
dir = self.make_controldir('.')
201
dir = self.make_bzrdir('.')
205
202
local_result = dir.cloning_metadir()
206
203
request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
207
204
request = request_class(backing)
215
212
"""The request fails when bzrdir contains a branch reference."""
216
213
backing = self.get_transport()
217
214
referenced_branch = self.make_branch('referenced')
218
dir = self.make_controldir('.')
215
dir = self.make_bzrdir('.')
219
216
local_result = dir.cloning_metadir()
220
reference = _mod_bzrbranch.BranchReferenceFormat().initialize(
217
reference = _mod_branch.BranchReferenceFormat().initialize(
221
218
dir, target_branch=referenced_branch)
222
reference_url = _mod_bzrbranch.BranchReferenceFormat().get_reference(dir)
219
reference_url = _mod_branch.BranchReferenceFormat().get_reference(dir)
223
220
# The server shouldn't try to follow the branch reference, so it's fine
224
221
# if the referenced branch isn't reachable.
225
222
backing.rename('referenced', 'moved')
254
251
def test_destroy_branch_default(self):
255
252
"""The default branch can be removed."""
256
253
backing = self.get_transport()
257
dir = self.make_branch('.').controldir
254
dir = self.make_branch('.').bzrdir
258
255
request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
259
256
request = request_class(backing)
260
257
expected = smart_req.SuccessfulSmartServerResponse(('ok',))
263
260
def test_destroy_branch_named(self):
264
261
"""A named branch can be removed."""
265
262
backing = self.get_transport()
266
dir = self.make_repository('.', format="development-colo").controldir
263
dir = self.make_repository('.', format="development-colo").bzrdir
267
264
dir.create_branch(name="branchname")
268
265
request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
269
266
request = request_class(backing)
273
270
def test_destroy_branch_missing(self):
274
271
"""An error is raised if the branch didn't exist."""
275
272
backing = self.get_transport()
276
dir = self.make_controldir('.', format="development-colo")
273
dir = self.make_bzrdir('.', format="development-colo")
277
274
request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
278
275
request = request_class(backing)
279
276
expected = smart_req.FailedSmartServerResponse(('nobranch',), None)
287
284
def test_has_workingtree_yes(self):
288
285
"""A working tree is present."""
289
286
backing = self.get_transport()
290
dir = self.make_branch_and_tree('.').controldir
287
dir = self.make_branch_and_tree('.').bzrdir
291
288
request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
292
289
request = request_class(backing)
293
290
expected = smart_req.SuccessfulSmartServerResponse(('yes',))
296
293
def test_has_workingtree_no(self):
297
294
"""A working tree is missing."""
298
295
backing = self.get_transport()
299
dir = self.make_controldir('.')
296
dir = self.make_bzrdir('.')
300
297
request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
301
298
request = request_class(backing)
302
299
expected = smart_req.SuccessfulSmartServerResponse(('no',))
310
307
def test_destroy_repository_default(self):
311
308
"""The repository can be removed."""
312
309
backing = self.get_transport()
313
dir = self.make_repository('.').controldir
310
dir = self.make_repository('.').bzrdir
314
311
request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
315
312
request = request_class(backing)
316
313
expected = smart_req.SuccessfulSmartServerResponse(('ok',))
319
316
def test_destroy_repository_missing(self):
320
317
"""An error is raised if the repository didn't exist."""
321
318
backing = self.get_transport()
322
dir = self.make_controldir('.')
319
dir = self.make_bzrdir('.')
323
320
request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
324
321
request = request_class(backing)
325
322
expected = smart_req.FailedSmartServerResponse(
333
330
def test_makes_repository(self):
334
331
"""When there is a bzrdir present, the call succeeds."""
335
332
backing = self.get_transport()
336
self.make_controldir('.')
333
self.make_bzrdir('.')
337
334
request_class = smart_dir.SmartServerRequestCreateRepository
338
335
request = request_class(backing)
339
336
reference_bzrdir_format = controldir.format_registry.get('pack-0.92')()
351
348
"""When there is no repository to be found, ('norepository', ) is returned."""
352
349
backing = self.get_transport()
353
350
request = self._request_class(backing)
354
self.make_controldir('.')
351
self.make_bzrdir('.')
355
352
self.assertEqual(smart_req.SmartServerResponse(('norepository', )),
356
353
request.execute(''))
363
360
request = self._request_class(backing)
364
361
result = self._make_repository_and_result()
365
362
self.assertEqual(result, request.execute(''))
366
self.make_controldir('subdir')
363
self.make_bzrdir('subdir')
367
364
self.assertEqual(smart_req.SmartServerResponse(('norepository', )),
368
365
request.execute('subdir'))
406
403
request = self._request_class(backing)
407
404
result = self._make_repository_and_result(shared=True)
408
405
self.assertEqual(result, request.execute(''))
409
self.make_controldir('subdir')
406
self.make_bzrdir('subdir')
410
407
result2 = smart_req.SmartServerResponse(
411
408
result.args[0:1] + ('..', ) + result.args[2:])
412
409
self.assertEqual(result2,
413
410
request.execute('subdir'))
414
self.make_controldir('subdir/deeper')
411
self.make_bzrdir('subdir/deeper')
415
412
result3 = smart_req.SmartServerResponse(
416
413
result.args[0:1] + ('../..', ) + result.args[2:])
417
414
self.assertEqual(result3,
446
443
def test_present(self):
447
444
backing = self.get_transport()
448
dir = self.make_controldir('.')
445
dir = self.make_bzrdir('.')
449
446
dir.get_config().set_default_stack_on("/")
450
447
local_result = dir._get_config()._get_config_file().read()
451
448
request_class = smart_dir.SmartServerBzrDirRequestConfigFile
456
453
def test_missing(self):
457
454
backing = self.get_transport()
458
dir = self.make_controldir('.')
455
dir = self.make_bzrdir('.')
459
456
request_class = smart_dir.SmartServerBzrDirRequestConfigFile
460
457
request = request_class(backing)
461
458
expected = smart_req.SuccessfulSmartServerResponse((), '')
480
477
def test_empty(self):
481
478
backing = self.get_transport()
482
dir = self.make_controldir('.')
479
dir = self.make_bzrdir('.')
483
480
request_class = smart_dir.SmartServerBzrDirRequestGetBranches
484
481
request = request_class(backing)
485
482
local_result = bencode.bencode({})
514
511
"""Initializing an extant bzrdir should fail like the bzrdir api."""
515
512
backing = self.get_transport()
516
513
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
517
self.make_controldir('subdir')
514
self.make_bzrdir('subdir')
518
515
self.assertRaises(errors.AlreadyControlDirError,
519
516
request.execute, 'subdir')
529
526
def test_empty_dir(self):
530
527
"""Initializing an empty dir should succeed and do it."""
531
528
backing = self.get_transport()
532
name = self.make_controldir('reference')._format.network_name()
529
name = self.make_bzrdir('reference')._format.network_name()
533
530
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
534
531
self.assertEqual(
535
532
smart_req.SmartServerResponse(('', '', '', '', '', '', name,
546
543
def test_missing_dir(self):
547
544
"""Initializing a missing directory should fail like the bzrdir api."""
548
545
backing = self.get_transport()
549
name = self.make_controldir('reference')._format.network_name()
546
name = self.make_bzrdir('reference')._format.network_name()
550
547
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
551
548
self.assertRaises(errors.NoSuchFile, request.execute, name,
552
549
'subdir/dir', 'False', 'False', 'False', '', '', '', '', 'False')
554
551
def test_initialized_dir(self):
555
552
"""Initializing an extant directory should fail like the bzrdir api."""
556
553
backing = self.get_transport()
557
name = self.make_controldir('reference')._format.network_name()
554
name = self.make_bzrdir('reference')._format.network_name()
558
555
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
559
self.make_controldir('subdir')
556
self.make_bzrdir('subdir')
560
557
self.assertRaises(errors.FileExists, request.execute, name, 'subdir',
561
558
'False', 'False', 'False', '', '', '', '', 'False')
602
599
def test_present_without_workingtree(self):
603
600
backing = self.get_transport()
604
601
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
605
self.make_controldir('.')
602
self.make_bzrdir('.')
606
603
self.assertEqual(smart_req.SmartServerResponse(('yes', 'no')),
607
604
request.execute(''))
620
617
self.vfs_transport_factory = test_server.LocalURLServer
621
618
backing = self.get_transport()
622
619
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
623
bd = self.make_controldir('.')
620
bd = self.make_bzrdir('.')
624
621
bd.create_repository()
625
622
bd.create_branch()
626
623
bd.create_workingtree()
634
631
"""When there is no branch, ('nobranch', ) is returned."""
635
632
backing = self.get_transport()
636
633
request = smart_dir.SmartServerRequestOpenBranch(backing)
637
self.make_controldir('.')
634
self.make_bzrdir('.')
638
635
self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
639
636
request.execute(''))
652
649
backing = self.get_transport()
653
650
request = smart_dir.SmartServerRequestOpenBranch(backing)
654
651
branch = self.make_branch('branch')
655
checkout = branch.create_checkout('reference', lightweight=True)
656
reference_url = _mod_bzrbranch.BranchReferenceFormat().get_reference(
652
checkout = branch.create_checkout('reference',lightweight=True)
653
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
658
655
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
659
656
self.assertEqual(smart_req.SmartServerResponse(('ok', reference_url)),
660
657
request.execute('reference'))
673
670
def test_no_branch(self):
674
671
"""When there is no branch, ('nobranch', ) is returned."""
675
672
backing = self.get_transport()
676
self.make_controldir('.')
673
self.make_bzrdir('.')
677
674
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
678
675
self.assertEqual(smart_req.SmartServerResponse(('nobranch', )),
679
676
request.execute(''))
693
690
backing = self.get_transport()
694
691
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
695
692
branch = self.make_branch('branch')
696
checkout = branch.create_checkout('reference', lightweight=True)
697
reference_url = _mod_bzrbranch.BranchReferenceFormat().get_reference(
693
checkout = branch.create_checkout('reference',lightweight=True)
694
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
699
696
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
700
697
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
701
698
('ref', reference_url)),
736
733
def test_no_branch(self):
737
734
"""When there is no branch, ('nobranch', ) is returned."""
738
735
backing = self.get_transport()
739
self.make_controldir('.')
736
self.make_bzrdir('.')
740
737
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
741
738
self.assertEqual(smart_req.SmartServerResponse(('nobranch',)),
742
739
request.execute(''))
756
753
backing = self.get_transport()
757
754
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
758
755
branch = self.make_branch('branch')
759
checkout = branch.create_checkout('reference', lightweight=True)
760
reference_url = _mod_bzrbranch.BranchReferenceFormat().get_reference(
756
checkout = branch.create_checkout('reference',lightweight=True)
757
reference_url = _mod_branch.BranchReferenceFormat().get_reference(
762
759
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
763
760
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
764
761
('ref', reference_url)),
826
823
"""When there is a bzrdir and no branch, NotBranchError is raised."""
827
824
backing = self.get_transport()
828
825
request = smart_branch.SmartServerBranchRequest(backing)
829
self.make_controldir('.')
826
self.make_bzrdir('.')
830
827
self.assertRaises(errors.NotBranchError,
831
828
request.execute, '')
835
832
backing = self.get_transport()
836
833
request = smart_branch.SmartServerBranchRequest(backing)
837
834
branch = self.make_branch('branch')
838
checkout = branch.create_checkout('reference', lightweight=True)
835
checkout = branch.create_checkout('reference',lightweight=True)
839
836
self.assertRaises(errors.NotBranchError,
840
837
request.execute, 'checkout')
930
927
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
932
929
def get_lock_tokens(self, branch):
933
branch_token = branch.lock_write().token
930
branch_token = branch.lock_write().branch_token
934
931
repo_token = branch.repository.lock_write().repository_token
935
932
branch.repository.unlock()
936
933
return branch_token, repo_token
947
944
self.assertEqual(
948
945
smart_req.SmartServerResponse(('ok', )),
949
946
request.do_body('foo bar baz'))
951
948
branch.control_transport.get_bytes('branch.conf'),
958
955
def test_value_name(self):
959
956
branch = self.make_branch('.')
960
957
request = smart_branch.SmartServerBranchRequestSetConfigOption(
961
branch.controldir.root_transport)
958
branch.bzrdir.root_transport)
962
959
branch_token, repo_token = self.get_lock_tokens(branch)
963
960
config = branch._get_config()
964
961
result = request.execute('', branch_token, repo_token, 'bar', 'foo',
971
968
def test_value_name_section(self):
972
969
branch = self.make_branch('.')
973
970
request = smart_branch.SmartServerBranchRequestSetConfigOption(
974
branch.controldir.root_transport)
971
branch.bzrdir.root_transport)
975
972
branch_token, repo_token = self.get_lock_tokens(branch)
976
973
config = branch._get_config()
977
974
result = request.execute('', branch_token, repo_token, 'bar', 'foo',
996
993
def test_value_name(self):
997
994
branch = self.make_branch('.')
998
995
request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
999
branch.controldir.root_transport)
996
branch.bzrdir.root_transport)
1000
997
branch_token, repo_token = self.get_lock_tokens(branch)
1001
998
config = branch._get_config()
1002
999
result = request.execute('', branch_token, repo_token,
1009
1006
def test_value_name_section(self):
1010
1007
branch = self.make_branch('.')
1011
1008
request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
1012
branch.controldir.root_transport)
1009
branch.bzrdir.root_transport)
1013
1010
branch_token, repo_token = self.get_lock_tokens(branch)
1014
1011
config = branch._get_config()
1015
1012
result = request.execute('', branch_token, repo_token,
1036
1033
response = request.do_chunk(tag_bytes)
1037
1034
self.assertEqual(None, response)
1038
1035
response = request.do_end()
1040
1037
smart_req.SuccessfulSmartServerResponse(()), response)
1041
1038
base_branch.unlock()
1105
1102
self.tree.add('')
1106
1103
rev_id_utf8 = u'\xc8'.encode('utf-8')
1107
1104
r1 = self.tree.commit('1st commit', rev_id=rev_id_utf8)
1108
r2 = self.tree.commit('2nd commit', rev_id=b'rev-2')
1105
r2 = self.tree.commit('2nd commit', rev_id='rev-2')
1109
1106
self.tree.unlock()
1111
1108
def test_branch_last_revision_info_is_updated(self):
1236
1233
self.tree.add('')
1237
1234
r1 = self.tree.commit('1st commit')
1238
1235
revno_1, revid_1 = self.tree.branch.last_revision_info()
1239
r2 = self.tree.commit('2nd commit', rev_id=b'child-1')
1236
r2 = self.tree.commit('2nd commit', rev_id='child-1')
1240
1237
# Undo the second commit
1241
1238
self.tree.branch.set_last_revision_info(revno_1, revid_1)
1242
1239
self.tree.set_parent_ids([revid_1])
1243
1240
# Make a new second commit, child-2. child-2 has diverged from
1245
new_r2 = self.tree.commit('2nd commit', rev_id=b'child-2')
1242
new_r2 = self.tree.commit('2nd commit', rev_id='child-2')
1246
1243
self.tree.unlock()
1248
1245
def test_not_allow_diverged(self):
1298
1295
base_branch = self.make_branch('base')
1299
1296
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
1300
1297
response = request.execute('base')
1302
1299
smart_req.SuccessfulSmartServerResponse(('',)), response)
1304
1301
def test_get_parent_something(self):
1306
1303
base_branch.set_parent(self.get_url('foo'))
1307
1304
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
1308
1305
response = request.execute('base')
1310
1307
smart_req.SuccessfulSmartServerResponse(("../foo",)),
1327
1324
branch.unlock()
1328
1325
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1329
1326
# Refresh branch as SetParentLocation modified it
1330
branch = branch.controldir.open_branch()
1327
branch = branch.bzrdir.open_branch()
1331
1328
self.assertEqual(None, branch.get_parent())
1333
1330
def test_set_parent_something(self):
1390
1387
# The branch (and associated repository) is now locked. Verify that
1391
1388
# with a new branch object.
1392
new_branch = repository.controldir.open_branch()
1389
new_branch = repository.bzrdir.open_branch()
1393
1390
self.assertRaises(errors.LockContention, new_branch.lock_write)
1395
1392
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1399
1396
backing = self.get_transport()
1400
1397
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1401
1398
branch = self.make_branch('.')
1402
branch_token = branch.lock_write().token
1399
branch_token = branch.lock_write().branch_token
1403
1400
branch.leave_lock_in_place()
1404
1401
branch.unlock()
1405
1402
response = request.execute('')
1488
1485
branch = self.make_branch('.')
1489
1486
branch_token, repo_token = self.get_lock_tokens(branch)
1490
self.assertEqual(True, branch.get_physical_lock_status())
1487
self.assertEquals(True, branch.get_physical_lock_status())
1491
1488
response = request.execute('')
1492
1489
self.assertEqual(
1493
1490
smart_req.SmartServerResponse(('yes',)), response)
1498
1495
request = smart_branch.SmartServerBranchRequestGetPhysicalLockStatus(
1500
1497
branch = self.make_branch('.')
1501
self.assertEqual(False, branch.get_physical_lock_status())
1498
self.assertEquals(False, branch.get_physical_lock_status())
1502
1499
response = request.execute('')
1503
1500
self.assertEqual(
1504
1501
smart_req.SmartServerResponse(('no',)), response)
1523
1520
smart_req.SmartServerResponse(('ok',)), response)
1524
1521
# The branch is now unlocked. Verify that with a new branch
1526
new_branch = branch.controldir.open_branch()
1523
new_branch = branch.bzrdir.open_branch()
1527
1524
new_branch.lock_write()
1528
1525
new_branch.unlock()
1566
1563
backing = self.get_transport()
1567
1564
request = smart_repo.SmartServerRepositoryRequest(backing)
1568
1565
self.make_repository('.', shared=True)
1569
self.make_controldir('subdir')
1566
self.make_bzrdir('subdir')
1570
1567
self.assertRaises(errors.NoRepositoryPresent,
1571
1568
request.execute, 'subdir')
1580
1577
write_token = tree.lock_write()
1581
1578
self.addCleanup(tree.unlock)
1583
tree.commit("Message", rev_id=b'rev1')
1580
tree.commit("Message", rev_id='rev1')
1584
1581
tree.branch.repository.start_write_group()
1585
1582
write_group_tokens = tree.branch.repository.suspend_write_group()
1586
1583
self.assertEqual(None, request.execute('', write_token,
1604
1601
backing = self.get_transport()
1605
1602
request = smart_repo.SmartServerRepositoryAllRevisionIds(backing)
1606
1603
self.make_repository('.')
1608
1605
smart_req.SuccessfulSmartServerResponse(("ok", ), ""),
1609
1606
request.execute(''))
1615
1612
tree = self.make_branch_and_memory_tree('.')
1616
1613
tree.lock_write()
1618
tree.commit(rev_id=b'origineel', message="message")
1619
tree.commit(rev_id=b'nog-een-revisie', message="message")
1615
tree.commit(rev_id='origineel', message="message")
1616
tree.commit(rev_id='nog-een-revisie', message="message")
1622
1619
smart_req.SuccessfulSmartServerResponse(("ok", ),
1623
1620
"origineel\nnog-een-revisie"),
1624
1621
request.execute(''))
1786
1783
response = request.do_body("rev1\nrev2")
1787
1784
self.assertTrue(response.is_successful())
1788
1785
# Format 2a uses serializer format 10
1789
self.assertEqual(response.args, ("ok", "10"))
1786
self.assertEquals(response.args, ("ok", "10"))
1791
1788
self.addCleanup(tree.branch.lock_read().unlock)
1792
1789
entries = [zlib.compress(record.get_bytes_as("fulltext")) for record in
1807
1804
response = request.do_body("rev1\nrev2")
1808
1805
self.assertTrue(response.is_successful())
1809
1806
# Format 2a uses serializer format 10
1810
self.assertEqual(response.args, ("ok", "10"))
1807
self.assertEquals(response.args, ("ok", "10"))
1812
1809
contents = "".join(response.body_stream)
1813
self.assertEqual(contents, "")
1810
self.assertEquals(contents, "")
1816
1813
class GetStreamTestBase(tests.TestCaseWithMemoryTransport):
1899
1896
request = smart_repo.SmartServerRepositoryIterFilesBytes(backing)
1900
1897
t = self.make_branch_and_tree('.')
1901
1898
self.addCleanup(t.lock_write().unlock)
1902
self.build_tree_contents([("file", b"somecontents")])
1903
t.add(["file"], [b"thefileid"])
1904
t.commit(rev_id=b'somerev', message="add file")
1899
self.build_tree_contents([("file", "somecontents")])
1900
t.add(["file"], ["thefileid"])
1901
t.commit(rev_id='somerev', message="add file")
1905
1902
self.assertIs(None, request.execute(''))
1906
1903
response = request.do_body("thefileid\0somerev\n")
1907
1904
self.assertTrue(response.is_successful())
1908
self.assertEqual(response.args, ("ok", ))
1909
self.assertEqual("".join(response.body_stream),
1905
self.assertEquals(response.args, ("ok", ))
1906
self.assertEquals("".join(response.body_stream),
1910
1907
"ok\x000\n" + zlib.compress("somecontents"))
1912
1909
def test_missing(self):
1917
1914
self.assertIs(None, request.execute(''))
1918
1915
response = request.do_body("thefileid\0revision\n")
1919
1916
self.assertTrue(response.is_successful())
1920
self.assertEqual(response.args, ("ok", ))
1921
self.assertEqual("".join(response.body_stream),
1917
self.assertEquals(response.args, ("ok", ))
1918
self.assertEquals("".join(response.body_stream),
1922
1919
"absent\x00thefileid\x00revision\x000\n")
1944
1941
tree = self.make_branch_and_memory_tree('.')
1945
1942
tree.lock_write()
1947
r1 = tree.commit('a commit', rev_id=b'A')
1944
r1 = tree.commit('a commit', rev_id='A')
1949
1946
self.assertTrue(tree.branch.repository.has_revision('A'))
1950
1947
self.assertEqual(smart_req.SmartServerResponse(('no', )),
1959
1956
tree = self.make_branch_and_memory_tree('.')
1960
1957
tree.lock_write()
1962
r1 = tree.commit('a commit', rev_id=b'A')
1959
r1 = tree.commit('a commit', rev_id='A')
1963
1960
tree.branch.repository.start_write_group()
1964
1961
tree.branch.repository.sign_revision('A', strategy)
1965
1962
tree.branch.repository.commit_write_group()
2066
2063
request = smart_repo.SmartServerRepositoryGetRevisionSignatureText(
2068
2065
bb = self.make_branch_builder('.')
2069
bb.build_commit(rev_id=b'A')
2066
bb.build_commit(rev_id='A')
2070
2067
repo = bb.get_branch().repository
2071
2068
strategy = gpg.LoopbackGPGStrategy(None)
2072
2069
self.addCleanup(repo.lock_write().unlock)
2115
2112
self.assertEqual(smart_req.SmartServerResponse(('ok', nonce)), response)
2116
2113
# The repository is now locked. Verify that with a new repository
2118
new_repo = repository.controldir.open_repository()
2115
new_repo = repository.bzrdir.open_repository()
2119
2116
self.assertRaises(errors.LockContention, new_repo.lock_write)
2121
2118
request = smart_repo.SmartServerRepositoryUnlock(backing)
2207
2204
smart_req.SmartServerResponse(('ok',)), response)
2208
2205
# The repository is now unlocked. Verify that with a new repository
2210
new_repo = repository.controldir.open_repository()
2207
new_repo = repository.bzrdir.open_repository()
2211
2208
new_repo.lock_write()
2212
2209
new_repo.unlock()
2241
2238
def test_without_write_lock(self):
2242
2239
backing = self.get_transport()
2243
2240
repo = self.make_repository('.')
2244
self.assertEqual(False, repo.get_physical_lock_status())
2241
self.assertEquals(False, repo.get_physical_lock_status())
2245
2242
request_class = smart_repo.SmartServerRepositoryGetPhysicalLockStatus
2246
2243
request = request_class(backing)
2247
2244
self.assertEqual(smart_req.SuccessfulSmartServerResponse(('no',)),
2292
2289
request = request_class(backing)
2293
2290
self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
2294
2291
request.execute('', 'False'))
2295
repo = repo.controldir.open_repository()
2292
repo = repo.bzrdir.open_repository()
2296
2293
self.assertFalse(repo.make_working_trees())
2298
2295
def test_set_true(self):
2303
2300
request = request_class(backing)
2304
2301
self.assertEqual(smart_req.SuccessfulSmartServerResponse(('ok',)),
2305
2302
request.execute('', 'True'))
2306
repo = repo.controldir.open_repository()
2303
repo = repo.bzrdir.open_repository()
2307
2304
self.assertTrue(repo.make_working_trees())
2467
2464
for key in smart_req.request_handlers.keys():
2469
2466
item = smart_req.request_handlers.get(key)
2470
except AttributeError as e:
2467
except AttributeError, e:
2471
2468
raise AttributeError('failed to get %s: %s' % (key, e))
2473
2470
def assertHandlerEqual(self, verb, handler):
2615
2612
self.server._sockname = ('example.com', 42)
2616
2613
self.server.run_server_started_hooks()
2617
self.assertEqual(started_calls,
2614
self.assertEquals(started_calls,
2618
2615
[([self.get_transport().base], 'bzr://example.com:42/')])
2619
self.assertEqual(started_ex_calls,
2616
self.assertEquals(started_ex_calls,
2620
2617
[([self.get_transport().base], self.server)])
2622
2619
def test_run_server_started_hooks_ipv6(self):
2627
2624
lambda backing_urls, url: started_calls.append((backing_urls, url)),
2629
2626
self.server.run_server_started_hooks()
2630
self.assertEqual(started_calls,
2627
self.assertEquals(started_calls,
2631
2628
[([self.get_transport().base], 'bzr://:::42/')])
2633
2630
def test_run_server_stopped_hooks(self):
2638
2635
lambda backing_urls, url: stopped_calls.append((backing_urls, url)),
2640
2637
self.server.run_server_stopped_hooks()
2641
self.assertEqual(stopped_calls,
2638
self.assertEquals(stopped_calls,
2642
2639
[([self.get_transport().base], 'bzr://example.com:42/')])
2671
2668
request = smart_repo.SmartServerRepositoryGetInventories(backing)
2672
2669
t = self.make_branch_and_tree('.', format='2a')
2673
2670
self.addCleanup(t.lock_write().unlock)
2674
self.build_tree_contents([("file", b"somecontents")])
2675
t.add(["file"], [b"thefileid"])
2676
t.commit(rev_id=b'somerev', message="add file")
2671
self.build_tree_contents([("file", "somecontents")])
2672
t.add(["file"], ["thefileid"])
2673
t.commit(rev_id='somerev', message="add file")
2677
2674
self.assertIs(None, request.execute('', 'unordered'))
2678
2675
response = request.do_body("somerev\n")
2679
2676
self.assertTrue(response.is_successful())
2680
self.assertEqual(response.args, ("ok", ))
2677
self.assertEquals(response.args, ("ok", ))
2681
2678
stream = [('inventory-deltas', [
2682
2679
versionedfile.FulltextContentFactory('somerev', None, None,
2683
2680
self._get_serialized_inventory_delta(
2684
2681
t.branch.repository, 'null:', 'somerev'))])]
2685
2682
fmt = controldir.format_registry.get('2a')().repository_format
2687
2684
"".join(response.body_stream),
2688
2685
"".join(smart_repo._stream_to_byte_stream(stream, fmt)))
2692
2689
request = smart_repo.SmartServerRepositoryGetInventories(backing)
2693
2690
t = self.make_branch_and_tree('.', format='2a')
2694
2691
self.addCleanup(t.lock_write().unlock)
2695
self.build_tree_contents([("file", b"somecontents")])
2696
t.add(["file"], [b"thefileid"])
2697
t.commit(rev_id=b'somerev', message="add file")
2692
self.build_tree_contents([("file", "somecontents")])
2693
t.add(["file"], ["thefileid"])
2694
t.commit(rev_id='somerev', message="add file")
2698
2695
self.assertIs(None, request.execute('', 'unordered'))
2699
2696
response = request.do_body("")
2700
2697
self.assertTrue(response.is_successful())
2701
self.assertEqual(response.args, ("ok", ))
2702
self.assertEqual("".join(response.body_stream),
2698
self.assertEquals(response.args, ("ok", ))
2699
self.assertEquals("".join(response.body_stream),
2703
2700
"Bazaar pack format 1 (introduced in 0.18)\nB54\n\nBazaar repository format 2a (needs bzr 1.16 or later)\nE")
added
removed
bzrlib/tests/test_smart.py
