1
# Copyright (C) 2006-2012, 2016 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Tests for the smart wire/domain protocol.
19
This module contains tests for the domain-level smart requests and responses,
20
such as the 'Branch.lock_write' request. Many of these use specific disk
21
formats to exercise calls that only make sense for formats with specific
24
Tests for low-level protocol encoding are found in test_smart_transport.
28
from io import BytesIO
34
branch as _mod_branch,
42
from breezy.bzr import (
43
branch as _mod_bzrbranch,
47
from breezy.bzr.smart import (
48
branch as smart_branch,
50
repository as smart_repo,
51
packrepository as smart_packrepo,
56
from breezy.bzr.testament import Testament
57
from breezy.tests import test_server
58
from breezy.transport import (
64
def load_tests(loader, standard_tests, pattern):
65
"""Multiply tests version and protocol consistency."""
66
# FindRepository tests.
69
"_request_class": smart_dir.SmartServerRequestFindRepositoryV1}),
70
("find_repositoryV2", {
71
"_request_class": smart_dir.SmartServerRequestFindRepositoryV2}),
72
("find_repositoryV3", {
73
"_request_class": smart_dir.SmartServerRequestFindRepositoryV3}),
75
to_adapt, result = tests.split_suite_by_re(
76
standard_tests, "TestSmartServerRequestFindRepository")
77
v2_only, v1_and_2 = tests.split_suite_by_re(to_adapt, "_v2")
78
tests.multiply_tests(v1_and_2, scenarios, result)
79
# The first scenario is only applicable to v1 protocols, it is deleted
81
tests.multiply_tests(v2_only, scenarios[1:], result)
85
class TestCaseWithChrootedTransport(tests.TestCaseWithTransport):
88
self.vfs_transport_factory = memory.MemoryServer
89
super(TestCaseWithChrootedTransport, self).setUp()
90
self._chroot_server = None
92
def get_transport(self, relpath=None):
93
if self._chroot_server is None:
94
backing_transport = tests.TestCaseWithTransport.get_transport(self)
95
self._chroot_server = chroot.ChrootServer(backing_transport)
96
self.start_server(self._chroot_server)
97
t = transport.get_transport_from_url(self._chroot_server.get_url())
98
if relpath is not None:
103
class TestCaseWithSmartMedium(tests.TestCaseWithMemoryTransport):
106
super(TestCaseWithSmartMedium, self).setUp()
107
# We're allowed to set the transport class here, so that we don't use
108
# the default or a parameterized class, but rather use the
109
# TestCaseWithTransport infrastructure to set up a smart server and
111
self.overrideAttr(self, "transport_server", self.make_transport_server)
113
def make_transport_server(self):
114
return test_server.SmartTCPServer_for_testing('-' + self.id())
116
def get_smart_medium(self):
117
"""Get a smart medium to use in tests."""
118
return self.get_transport().get_smart_medium()
121
class TestByteStreamToStream(tests.TestCase):
123
def test_repeated_substreams_same_kind_are_one_stream(self):
124
# Make a stream - an iterable of bytestrings.
126
('text', [versionedfile.FulltextContentFactory((b'k1',), None,
128
('text', [versionedfile.FulltextContentFactory((b'k2',), None,
130
fmt = controldir.format_registry.get('pack-0.92')().repository_format
131
bytes = smart_repo._stream_to_byte_stream(stream, fmt)
133
# Iterate the resulting iterable; checking that we get only one stream
135
fmt, stream = smart_repo._byte_stream_to_stream(bytes)
136
for kind, substream in stream:
137
streams.append((kind, list(substream)))
138
self.assertLength(1, streams)
139
self.assertLength(2, streams[0][1])
142
class TestSmartServerResponse(tests.TestCase):
144
def test__eq__(self):
145
self.assertEqual(smart_req.SmartServerResponse((b'ok', )),
146
smart_req.SmartServerResponse((b'ok', )))
147
self.assertEqual(smart_req.SmartServerResponse((b'ok', ), b'body'),
148
smart_req.SmartServerResponse((b'ok', ), b'body'))
149
self.assertNotEqual(smart_req.SmartServerResponse((b'ok', )),
150
smart_req.SmartServerResponse((b'notok', )))
151
self.assertNotEqual(smart_req.SmartServerResponse((b'ok', ), b'body'),
152
smart_req.SmartServerResponse((b'ok', )))
153
self.assertNotEqual(None,
154
smart_req.SmartServerResponse((b'ok', )))
156
def test__str__(self):
157
"""SmartServerResponses can be stringified."""
159
str(smart_req.SuccessfulSmartServerResponse((b'args',), b'body')),
160
("<SuccessfulSmartServerResponse args=(b'args',) body=b'body'>",
161
"<SuccessfulSmartServerResponse args=('args',) body='body'>"))
163
str(smart_req.FailedSmartServerResponse((b'args',), b'body')),
164
("<FailedSmartServerResponse args=(b'args',) body=b'body'>",
165
"<FailedSmartServerResponse args=('args',) body='body'>"))
168
class TestSmartServerRequest(tests.TestCaseWithMemoryTransport):
170
def test_translate_client_path(self):
171
transport = self.get_transport()
172
request = smart_req.SmartServerRequest(transport, 'foo/')
173
self.assertEqual('./', request.translate_client_path(b'foo/'))
175
urlutils.InvalidURLJoin, request.translate_client_path, b'foo/..')
177
errors.PathNotChild, request.translate_client_path, b'/')
179
errors.PathNotChild, request.translate_client_path, b'bar/')
180
self.assertEqual('./baz', request.translate_client_path(b'foo/baz'))
181
e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'
183
u'./' + urlutils.escape(e_acute),
184
request.translate_client_path(b'foo/' + e_acute.encode('utf-8')))
186
def test_translate_client_path_vfs(self):
187
"""VfsRequests receive escaped paths rather than raw UTF-8."""
188
transport = self.get_transport()
189
request = vfs.VfsRequest(transport, 'foo/')
190
e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'
191
escaped = urlutils.escape(u'foo/' + e_acute)
193
'./' + urlutils.escape(e_acute),
194
request.translate_client_path(escaped.encode('ascii')))
196
def test_transport_from_client_path(self):
197
transport = self.get_transport()
198
request = smart_req.SmartServerRequest(transport, 'foo/')
201
request.transport_from_client_path(b'foo/').base)
204
class TestSmartServerBzrDirRequestCloningMetaDir(
205
tests.TestCaseWithMemoryTransport):
206
"""Tests for BzrDir.cloning_metadir."""
208
def test_cloning_metadir(self):
209
"""When there is a bzrdir present, the call succeeds."""
210
backing = self.get_transport()
211
dir = self.make_controldir('.')
212
local_result = dir.cloning_metadir()
213
request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
214
request = request_class(backing)
215
expected = smart_req.SuccessfulSmartServerResponse(
216
(local_result.network_name(),
217
local_result.repository_format.network_name(),
218
(b'branch', local_result.get_branch_format().network_name())))
219
self.assertEqual(expected, request.execute(b'', b'False'))
221
def test_cloning_metadir_reference(self):
222
"""The request fails when bzrdir contains a branch reference."""
223
backing = self.get_transport()
224
referenced_branch = self.make_branch('referenced')
225
dir = self.make_controldir('.')
226
dir.cloning_metadir()
227
_mod_bzrbranch.BranchReferenceFormat().initialize(
228
dir, target_branch=referenced_branch)
229
_mod_bzrbranch.BranchReferenceFormat().get_reference(dir)
230
# The server shouldn't try to follow the branch reference, so it's fine
231
# if the referenced branch isn't reachable.
232
backing.rename('referenced', 'moved')
233
request_class = smart_dir.SmartServerBzrDirRequestCloningMetaDir
234
request = request_class(backing)
235
expected = smart_req.FailedSmartServerResponse((b'BranchReference',))
236
self.assertEqual(expected, request.execute(b'', b'False'))
239
class TestSmartServerBzrDirRequestCheckoutMetaDir(
240
tests.TestCaseWithMemoryTransport):
241
"""Tests for BzrDir.checkout_metadir."""
243
def test_checkout_metadir(self):
244
backing = self.get_transport()
245
request = smart_dir.SmartServerBzrDirRequestCheckoutMetaDir(
247
self.make_branch('.', format='2a')
248
response = request.execute(b'')
250
smart_req.SmartServerResponse(
251
(b'Bazaar-NG meta directory, format 1\n',
252
b'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
253
b'Bazaar Branch Format 7 (needs bzr 1.6)\n')),
257
class TestSmartServerBzrDirRequestDestroyBranch(
258
tests.TestCaseWithMemoryTransport):
259
"""Tests for BzrDir.destroy_branch."""
261
def test_destroy_branch_default(self):
262
"""The default branch can be removed."""
263
backing = self.get_transport()
264
self.make_branch('.')
265
request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
266
request = request_class(backing)
267
expected = smart_req.SuccessfulSmartServerResponse((b'ok',))
268
self.assertEqual(expected, request.execute(b'', None))
270
def test_destroy_branch_named(self):
271
"""A named branch can be removed."""
272
backing = self.get_transport()
273
dir = self.make_repository('.', format="development-colo").controldir
274
dir.create_branch(name="branchname")
275
request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
276
request = request_class(backing)
277
expected = smart_req.SuccessfulSmartServerResponse((b'ok',))
278
self.assertEqual(expected, request.execute(b'', b"branchname"))
280
def test_destroy_branch_missing(self):
281
"""An error is raised if the branch didn't exist."""
282
backing = self.get_transport()
283
self.make_controldir('.', format="development-colo")
284
request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
285
request = request_class(backing)
286
expected = smart_req.FailedSmartServerResponse((b'nobranch',), None)
287
self.assertEqual(expected, request.execute(b'', b"branchname"))
290
class TestSmartServerBzrDirRequestHasWorkingTree(
291
tests.TestCaseWithTransport):
292
"""Tests for BzrDir.has_workingtree."""
294
def test_has_workingtree_yes(self):
295
"""A working tree is present."""
296
backing = self.get_transport()
297
self.make_branch_and_tree('.')
298
request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
299
request = request_class(backing)
300
expected = smart_req.SuccessfulSmartServerResponse((b'yes',))
301
self.assertEqual(expected, request.execute(b''))
303
def test_has_workingtree_no(self):
304
"""A working tree is missing."""
305
backing = self.get_transport()
306
self.make_controldir('.')
307
request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
308
request = request_class(backing)
309
expected = smart_req.SuccessfulSmartServerResponse((b'no',))
310
self.assertEqual(expected, request.execute(b''))
313
class TestSmartServerBzrDirRequestDestroyRepository(
314
tests.TestCaseWithMemoryTransport):
315
"""Tests for BzrDir.destroy_repository."""
317
def test_destroy_repository_default(self):
318
"""The repository can be removed."""
319
backing = self.get_transport()
320
self.make_repository('.')
321
request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
322
request = request_class(backing)
323
expected = smart_req.SuccessfulSmartServerResponse((b'ok',))
324
self.assertEqual(expected, request.execute(b''))
326
def test_destroy_repository_missing(self):
327
"""An error is raised if the repository didn't exist."""
328
backing = self.get_transport()
329
self.make_controldir('.')
330
request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
331
request = request_class(backing)
332
expected = smart_req.FailedSmartServerResponse(
333
(b'norepository',), None)
334
self.assertEqual(expected, request.execute(b''))
337
class TestSmartServerRequestCreateRepository(
338
tests.TestCaseWithMemoryTransport):
339
"""Tests for BzrDir.create_repository."""
341
def test_makes_repository(self):
342
"""When there is a bzrdir present, the call succeeds."""
343
backing = self.get_transport()
344
self.make_controldir('.')
345
request_class = smart_dir.SmartServerRequestCreateRepository
346
request = request_class(backing)
347
reference_bzrdir_format = controldir.format_registry.get('pack-0.92')()
348
reference_format = reference_bzrdir_format.repository_format
349
network_name = reference_format.network_name()
350
expected = smart_req.SuccessfulSmartServerResponse(
351
(b'ok', b'no', b'no', b'no', network_name))
352
self.assertEqual(expected, request.execute(b'', network_name, b'True'))
355
class TestSmartServerRequestFindRepository(tests.TestCaseWithMemoryTransport):
356
"""Tests for BzrDir.find_repository."""
358
def test_no_repository(self):
359
"""If no repository is found, ('norepository', ) is returned."""
360
backing = self.get_transport()
361
request = self._request_class(backing)
362
self.make_controldir('.')
363
self.assertEqual(smart_req.SmartServerResponse((b'norepository', )),
364
request.execute(b''))
366
def test_nonshared_repository(self):
367
# nonshared repositorys only allow 'find' to return a handle when the
368
# path the repository is being searched on is the same as that that
369
# the repository is at.
370
backing = self.get_transport()
371
request = self._request_class(backing)
372
result = self._make_repository_and_result()
373
self.assertEqual(result, request.execute(b''))
374
self.make_controldir('subdir')
375
self.assertEqual(smart_req.SmartServerResponse((b'norepository', )),
376
request.execute(b'subdir'))
378
def _make_repository_and_result(self, shared=False, format=None):
379
"""Convenience function to setup a repository.
381
:result: The SmartServerResponse to expect when opening it.
383
repo = self.make_repository('.', shared=shared, format=format)
384
if repo.supports_rich_root():
388
if repo._format.supports_tree_reference:
392
if repo._format.supports_external_lookups:
396
if (smart_dir.SmartServerRequestFindRepositoryV3 ==
397
self._request_class):
398
return smart_req.SuccessfulSmartServerResponse(
399
(b'ok', b'', rich_root, subtrees, external,
400
repo._format.network_name()))
401
elif (smart_dir.SmartServerRequestFindRepositoryV2 ==
402
self._request_class):
403
# All tests so far are on formats, and for non-external
405
return smart_req.SuccessfulSmartServerResponse(
406
(b'ok', b'', rich_root, subtrees, external))
408
return smart_req.SuccessfulSmartServerResponse(
409
(b'ok', b'', rich_root, subtrees))
411
def test_shared_repository(self):
412
"""for a shared repository, we get 'ok', 'relpath-to-repo'."""
413
backing = self.get_transport()
414
request = self._request_class(backing)
415
result = self._make_repository_and_result(shared=True)
416
self.assertEqual(result, request.execute(b''))
417
self.make_controldir('subdir')
418
result2 = smart_req.SmartServerResponse(
419
result.args[0:1] + (b'..', ) + result.args[2:])
420
self.assertEqual(result2,
421
request.execute(b'subdir'))
422
self.make_controldir('subdir/deeper')
423
result3 = smart_req.SmartServerResponse(
424
result.args[0:1] + (b'../..', ) + result.args[2:])
425
self.assertEqual(result3,
426
request.execute(b'subdir/deeper'))
428
def test_rich_root_and_subtree_encoding(self):
429
"""Test for the format attributes for rich root and subtree support."""
430
backing = self.get_transport()
431
request = self._request_class(backing)
432
result = self._make_repository_and_result(
433
format='development-subtree')
434
# check the test will be valid
435
self.assertEqual(b'yes', result.args[2])
436
self.assertEqual(b'yes', result.args[3])
437
self.assertEqual(result, request.execute(b''))
439
def test_supports_external_lookups_no_v2(self):
440
"""Test for the supports_external_lookups attribute."""
441
backing = self.get_transport()
442
request = self._request_class(backing)
443
result = self._make_repository_and_result(
444
format='development-subtree')
445
# check the test will be valid
446
self.assertEqual(b'yes', result.args[4])
447
self.assertEqual(result, request.execute(b''))
450
class TestSmartServerBzrDirRequestGetConfigFile(
451
tests.TestCaseWithMemoryTransport):
452
"""Tests for BzrDir.get_config_file."""
454
def test_present(self):
455
backing = self.get_transport()
456
dir = self.make_controldir('.')
457
dir.get_config().set_default_stack_on("/")
458
local_result = dir._get_config()._get_config_file().read()
459
request_class = smart_dir.SmartServerBzrDirRequestConfigFile
460
request = request_class(backing)
461
expected = smart_req.SuccessfulSmartServerResponse((), local_result)
462
self.assertEqual(expected, request.execute(b''))
464
def test_missing(self):
465
backing = self.get_transport()
466
self.make_controldir('.')
467
request_class = smart_dir.SmartServerBzrDirRequestConfigFile
468
request = request_class(backing)
469
expected = smart_req.SuccessfulSmartServerResponse((), b'')
470
self.assertEqual(expected, request.execute(b''))
473
class TestSmartServerBzrDirRequestGetBranches(
474
tests.TestCaseWithMemoryTransport):
475
"""Tests for BzrDir.get_branches."""
477
def test_simple(self):
478
backing = self.get_transport()
479
branch = self.make_branch('.')
480
request_class = smart_dir.SmartServerBzrDirRequestGetBranches
481
request = request_class(backing)
482
local_result = bencode.bencode(
483
{b"": (b"branch", branch._format.network_name())})
484
expected = smart_req.SuccessfulSmartServerResponse(
485
(b"success", ), local_result)
486
self.assertEqual(expected, request.execute(b''))
488
def test_empty(self):
489
backing = self.get_transport()
490
self.make_controldir('.')
491
request_class = smart_dir.SmartServerBzrDirRequestGetBranches
492
request = request_class(backing)
493
local_result = bencode.bencode({})
494
expected = smart_req.SuccessfulSmartServerResponse(
495
(b'success',), local_result)
496
self.assertEqual(expected, request.execute(b''))
499
class TestSmartServerRequestInitializeBzrDir(
500
tests.TestCaseWithMemoryTransport):
502
def test_empty_dir(self):
503
"""Initializing an empty dir should succeed and do it."""
504
backing = self.get_transport()
505
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
506
self.assertEqual(smart_req.SmartServerResponse((b'ok', )),
507
request.execute(b''))
508
made_dir = controldir.ControlDir.open_from_transport(backing)
509
# no branch, tree or repository is expected with the current
511
self.assertRaises(errors.NoWorkingTree, made_dir.open_workingtree)
512
self.assertRaises(errors.NotBranchError, made_dir.open_branch)
513
self.assertRaises(errors.NoRepositoryPresent, made_dir.open_repository)
515
def test_missing_dir(self):
516
"""Initializing a missing directory should fail like the bzrdir api."""
517
backing = self.get_transport()
518
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
519
self.assertRaises(errors.NoSuchFile,
520
request.execute, b'subdir')
522
def test_initialized_dir(self):
523
"""Initializing an extant bzrdir should fail like the bzrdir api."""
524
backing = self.get_transport()
525
request = smart_dir.SmartServerRequestInitializeBzrDir(backing)
526
self.make_controldir('subdir')
527
self.assertRaises(errors.AlreadyControlDirError,
528
request.execute, b'subdir')
531
class TestSmartServerRequestBzrDirInitializeEx(
532
tests.TestCaseWithMemoryTransport):
533
"""Basic tests for BzrDir.initialize_ex_1.16 in the smart server.
535
The main unit tests in test_bzrdir exercise the API comprehensively.
538
def test_empty_dir(self):
539
"""Initializing an empty dir should succeed and do it."""
540
backing = self.get_transport()
541
name = self.make_controldir('reference')._format.network_name()
542
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
544
smart_req.SmartServerResponse((b'', b'', b'', b'', b'', b'', name,
545
b'False', b'', b'', b'')),
546
request.execute(name, b'', b'True', b'False', b'False', b'', b'',
548
made_dir = controldir.ControlDir.open_from_transport(backing)
549
# no branch, tree or repository is expected with the current
551
self.assertRaises(errors.NoWorkingTree, made_dir.open_workingtree)
552
self.assertRaises(errors.NotBranchError, made_dir.open_branch)
553
self.assertRaises(errors.NoRepositoryPresent, made_dir.open_repository)
555
def test_missing_dir(self):
556
"""Initializing a missing directory should fail like the bzrdir api."""
557
backing = self.get_transport()
558
name = self.make_controldir('reference')._format.network_name()
559
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
560
self.assertRaises(errors.NoSuchFile, request.execute, name,
561
b'subdir/dir', b'False', b'False', b'False', b'',
562
b'', b'', b'', b'False')
564
def test_initialized_dir(self):
565
"""Initializing an extant directory should fail like the bzrdir api."""
566
backing = self.get_transport()
567
name = self.make_controldir('reference')._format.network_name()
568
request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
569
self.make_controldir('subdir')
570
self.assertRaises(errors.FileExists, request.execute, name, b'subdir',
571
b'False', b'False', b'False', b'', b'', b'', b'',
575
class TestSmartServerRequestOpenBzrDir(tests.TestCaseWithMemoryTransport):
577
def test_no_directory(self):
578
backing = self.get_transport()
579
request = smart_dir.SmartServerRequestOpenBzrDir(backing)
580
self.assertEqual(smart_req.SmartServerResponse((b'no', )),
581
request.execute(b'does-not-exist'))
583
def test_empty_directory(self):
584
backing = self.get_transport()
585
backing.mkdir('empty')
586
request = smart_dir.SmartServerRequestOpenBzrDir(backing)
587
self.assertEqual(smart_req.SmartServerResponse((b'no', )),
588
request.execute(b'empty'))
590
def test_outside_root_client_path(self):
591
backing = self.get_transport()
592
request = smart_dir.SmartServerRequestOpenBzrDir(
593
backing, root_client_path='root')
594
self.assertEqual(smart_req.SmartServerResponse((b'no', )),
595
request.execute(b'not-root'))
598
class TestSmartServerRequestOpenBzrDir_2_1(tests.TestCaseWithMemoryTransport):
600
def test_no_directory(self):
601
backing = self.get_transport()
602
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
603
self.assertEqual(smart_req.SmartServerResponse((b'no', )),
604
request.execute(b'does-not-exist'))
606
def test_empty_directory(self):
607
backing = self.get_transport()
608
backing.mkdir('empty')
609
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
610
self.assertEqual(smart_req.SmartServerResponse((b'no', )),
611
request.execute(b'empty'))
613
def test_present_without_workingtree(self):
614
backing = self.get_transport()
615
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
616
self.make_controldir('.')
617
self.assertEqual(smart_req.SmartServerResponse((b'yes', b'no')),
618
request.execute(b''))
620
def test_outside_root_client_path(self):
621
backing = self.get_transport()
622
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(
623
backing, root_client_path='root')
624
self.assertEqual(smart_req.SmartServerResponse((b'no',)),
625
request.execute(b'not-root'))
628
class TestSmartServerRequestOpenBzrDir_2_1_disk(TestCaseWithChrootedTransport):
630
def test_present_with_workingtree(self):
631
self.vfs_transport_factory = test_server.LocalURLServer
632
backing = self.get_transport()
633
request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing)
634
bd = self.make_controldir('.')
635
bd.create_repository()
637
bd.create_workingtree()
638
self.assertEqual(smart_req.SmartServerResponse((b'yes', b'yes')),
639
request.execute(b''))
642
class TestSmartServerRequestOpenBranch(TestCaseWithChrootedTransport):
644
def test_no_branch(self):
645
"""When there is no branch, ('nobranch', ) is returned."""
646
backing = self.get_transport()
647
request = smart_dir.SmartServerRequestOpenBranch(backing)
648
self.make_controldir('.')
649
self.assertEqual(smart_req.SmartServerResponse((b'nobranch', )),
650
request.execute(b''))
652
def test_branch(self):
653
"""When there is a branch, 'ok' is returned."""
654
backing = self.get_transport()
655
request = smart_dir.SmartServerRequestOpenBranch(backing)
656
self.make_branch('.')
657
self.assertEqual(smart_req.SmartServerResponse((b'ok', b'')),
658
request.execute(b''))
660
def test_branch_reference(self):
661
"""When there is a branch reference, the reference URL is returned."""
662
self.vfs_transport_factory = test_server.LocalURLServer
663
backing = self.get_transport()
664
request = smart_dir.SmartServerRequestOpenBranch(backing)
665
branch = self.make_branch('branch')
666
checkout = branch.create_checkout('reference', lightweight=True)
667
reference_url = _mod_bzrbranch.BranchReferenceFormat().get_reference(
668
checkout.controldir).encode('utf-8')
669
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
670
self.assertEqual(smart_req.SmartServerResponse((b'ok', reference_url)),
671
request.execute(b'reference'))
673
def test_notification_on_branch_from_repository(self):
674
"""When there is a repository, the error should return details."""
675
backing = self.get_transport()
676
request = smart_dir.SmartServerRequestOpenBranch(backing)
677
self.make_repository('.')
678
self.assertEqual(smart_req.SmartServerResponse((b'nobranch',)),
679
request.execute(b''))
682
class TestSmartServerRequestOpenBranchV2(TestCaseWithChrootedTransport):
684
def test_no_branch(self):
685
"""When there is no branch, ('nobranch', ) is returned."""
686
backing = self.get_transport()
687
self.make_controldir('.')
688
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
689
self.assertEqual(smart_req.SmartServerResponse((b'nobranch', )),
690
request.execute(b''))
692
def test_branch(self):
693
"""When there is a branch, 'ok' is returned."""
694
backing = self.get_transport()
695
expected = self.make_branch('.')._format.network_name()
696
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
697
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
698
(b'branch', expected)),
699
request.execute(b''))
701
def test_branch_reference(self):
702
"""When there is a branch reference, the reference URL is returned."""
703
self.vfs_transport_factory = test_server.LocalURLServer
704
backing = self.get_transport()
705
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
706
branch = self.make_branch('branch')
707
checkout = branch.create_checkout('reference', lightweight=True)
708
reference_url = _mod_bzrbranch.BranchReferenceFormat().get_reference(
709
checkout.controldir).encode('utf-8')
710
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
711
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
712
(b'ref', reference_url)),
713
request.execute(b'reference'))
715
def test_stacked_branch(self):
716
"""Opening a stacked branch does not open the stacked-on branch."""
717
trunk = self.make_branch('trunk')
718
feature = self.make_branch('feature')
719
feature.set_stacked_on_url(trunk.base)
721
_mod_branch.Branch.hooks.install_named_hook(
722
'open', opened_branches.append, None)
723
backing = self.get_transport()
724
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
727
response = request.execute(b'feature')
729
request.teardown_jail()
730
expected_format = feature._format.network_name()
731
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
732
(b'branch', expected_format)),
734
self.assertLength(1, opened_branches)
736
def test_notification_on_branch_from_repository(self):
737
"""When there is a repository, the error should return details."""
738
backing = self.get_transport()
739
request = smart_dir.SmartServerRequestOpenBranchV2(backing)
740
self.make_repository('.')
741
self.assertEqual(smart_req.SmartServerResponse((b'nobranch',)),
742
request.execute(b''))
745
class TestSmartServerRequestOpenBranchV3(TestCaseWithChrootedTransport):
747
def test_no_branch(self):
748
"""When there is no branch, ('nobranch', ) is returned."""
749
backing = self.get_transport()
750
self.make_controldir('.')
751
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
752
self.assertEqual(smart_req.SmartServerResponse((b'nobranch',)),
753
request.execute(b''))
755
def test_branch(self):
756
"""When there is a branch, 'ok' is returned."""
757
backing = self.get_transport()
758
expected = self.make_branch('.')._format.network_name()
759
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
760
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
761
(b'branch', expected)),
762
request.execute(b''))
764
def test_branch_reference(self):
765
"""When there is a branch reference, the reference URL is returned."""
766
self.vfs_transport_factory = test_server.LocalURLServer
767
backing = self.get_transport()
768
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
769
branch = self.make_branch('branch')
770
checkout = branch.create_checkout('reference', lightweight=True)
771
reference_url = _mod_bzrbranch.BranchReferenceFormat().get_reference(
772
checkout.controldir).encode('utf-8')
773
self.assertFileEqual(reference_url, 'reference/.bzr/branch/location')
774
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
775
(b'ref', reference_url)),
776
request.execute(b'reference'))
778
def test_stacked_branch(self):
779
"""Opening a stacked branch does not open the stacked-on branch."""
780
trunk = self.make_branch('trunk')
781
feature = self.make_branch('feature')
782
feature.set_stacked_on_url(trunk.base)
784
_mod_branch.Branch.hooks.install_named_hook(
785
'open', opened_branches.append, None)
786
backing = self.get_transport()
787
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
790
response = request.execute(b'feature')
792
request.teardown_jail()
793
expected_format = feature._format.network_name()
794
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
795
(b'branch', expected_format)),
797
self.assertLength(1, opened_branches)
799
def test_notification_on_branch_from_repository(self):
800
"""When there is a repository, the error should return details."""
801
backing = self.get_transport()
802
request = smart_dir.SmartServerRequestOpenBranchV3(backing)
803
self.make_repository('.')
804
self.assertEqual(smart_req.SmartServerResponse(
805
(b'nobranch', b'location is a repository')),
806
request.execute(b''))
809
class TestSmartServerRequestRevisionHistory(tests.TestCaseWithMemoryTransport):
811
def test_empty(self):
812
"""For an empty branch, the body is empty."""
813
backing = self.get_transport()
814
request = smart_branch.SmartServerRequestRevisionHistory(backing)
815
self.make_branch('.')
816
self.assertEqual(smart_req.SmartServerResponse((b'ok', ), b''),
817
request.execute(b''))
819
def test_not_empty(self):
820
"""For a non-empty branch, the body is empty."""
821
backing = self.get_transport()
822
request = smart_branch.SmartServerRequestRevisionHistory(backing)
823
tree = self.make_branch_and_memory_tree('.')
826
r1 = tree.commit('1st commit')
827
r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
830
smart_req.SmartServerResponse((b'ok', ), (b'\x00'.join([r1, r2]))),
831
request.execute(b''))
834
class TestSmartServerBranchRequest(tests.TestCaseWithMemoryTransport):
836
def test_no_branch(self):
837
"""When there is a bzrdir and no branch, NotBranchError is raised."""
838
backing = self.get_transport()
839
request = smart_branch.SmartServerBranchRequest(backing)
840
self.make_controldir('.')
841
self.assertRaises(errors.NotBranchError,
842
request.execute, b'')
844
def test_branch_reference(self):
845
"""When there is a branch reference, NotBranchError is raised."""
846
backing = self.get_transport()
847
request = smart_branch.SmartServerBranchRequest(backing)
848
branch = self.make_branch('branch')
849
branch.create_checkout('reference', lightweight=True)
850
self.assertRaises(errors.NotBranchError,
851
request.execute, b'checkout')
854
class TestSmartServerBranchRequestLastRevisionInfo(
855
tests.TestCaseWithMemoryTransport):
857
def test_empty(self):
858
"""For an empty branch, the result is ('ok', '0', b'null:')."""
859
backing = self.get_transport()
860
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(
862
self.make_branch('.')
864
smart_req.SmartServerResponse((b'ok', b'0', b'null:')),
865
request.execute(b''))
867
def test_ghost(self):
868
"""For an empty branch, the result is ('ok', '0', b'null:')."""
869
backing = self.get_transport()
870
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(
872
branch = self.make_branch('.')
874
def last_revision_info():
875
raise errors.GhostRevisionsHaveNoRevno(b'revid1', b'revid2')
876
self.overrideAttr(branch, 'last_revision_info', last_revision_info)
877
self.assertRaises(errors.GhostRevisionsHaveNoRevno,
878
request.do_with_branch, branch)
880
def test_not_empty(self):
881
"""For a non-empty branch, the result is ('ok', 'revno', 'revid')."""
882
backing = self.get_transport()
883
request = smart_branch.SmartServerBranchRequestLastRevisionInfo(
885
tree = self.make_branch_and_memory_tree('.')
888
rev_id_utf8 = u'\xc8'.encode('utf-8')
889
tree.commit('1st commit')
890
tree.commit('2nd commit', rev_id=rev_id_utf8)
893
smart_req.SmartServerResponse((b'ok', b'2', rev_id_utf8)),
894
request.execute(b''))
897
class TestSmartServerBranchRequestRevisionIdToRevno(
898
tests.TestCaseWithMemoryTransport):
901
backing = self.get_transport()
902
request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
904
self.make_branch('.')
905
self.assertEqual(smart_req.SmartServerResponse((b'ok', b'0')),
906
request.execute(b'', b'null:'))
908
def test_ghost_revision(self):
909
backing = self.get_transport()
910
request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
912
branch = self.make_branch('.')
913
def revision_id_to_dotted_revno(revid):
914
raise errors.GhostRevisionsHaveNoRevno(revid, b'ghost-revid')
915
self.overrideAttr(branch, 'revision_id_to_dotted_revno', revision_id_to_dotted_revno)
917
smart_req.FailedSmartServerResponse(
918
(b'GhostRevisionsHaveNoRevno', b'revid', b'ghost-revid')),
919
request.do_with_branch(branch, b'revid'))
921
def test_simple(self):
922
backing = self.get_transport()
923
request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
925
tree = self.make_branch_and_memory_tree('.')
928
r1 = tree.commit('1st commit')
931
smart_req.SmartServerResponse((b'ok', b'1')),
932
request.execute(b'', r1))
934
def test_not_found(self):
935
backing = self.get_transport()
936
request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
938
self.make_branch('.')
940
smart_req.FailedSmartServerResponse(
941
(b'NoSuchRevision', b'idontexist')),
942
request.execute(b'', b'idontexist'))
945
class TestSmartServerBranchRequestGetConfigFile(
946
tests.TestCaseWithMemoryTransport):
948
def test_default(self):
949
"""With no file, we get empty content."""
950
backing = self.get_transport()
951
request = smart_branch.SmartServerBranchGetConfigFile(backing)
952
self.make_branch('.')
953
# there should be no file by default
955
self.assertEqual(smart_req.SmartServerResponse((b'ok', ), content),
956
request.execute(b''))
958
def test_with_content(self):
959
# SmartServerBranchGetConfigFile should return the content from
960
# branch.control_files.get('branch.conf') for now - in the future it
961
# may perform more complex processing.
962
backing = self.get_transport()
963
request = smart_branch.SmartServerBranchGetConfigFile(backing)
964
branch = self.make_branch('.')
965
branch._transport.put_bytes('branch.conf', b'foo bar baz')
967
smart_req.SmartServerResponse((b'ok', ), b'foo bar baz'),
968
request.execute(b''))
971
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
973
def get_lock_tokens(self, branch):
974
branch_token = branch.lock_write().token
975
repo_token = branch.repository.lock_write().repository_token
976
branch.repository.unlock()
977
return branch_token, repo_token
980
class TestSmartServerBranchRequestPutConfigFile(TestLockedBranch):
982
def test_with_content(self):
983
backing = self.get_transport()
984
request = smart_branch.SmartServerBranchPutConfigFile(backing)
985
branch = self.make_branch('.')
986
branch_token, repo_token = self.get_lock_tokens(branch)
987
self.assertIs(None, request.execute(b'', branch_token, repo_token))
989
smart_req.SmartServerResponse((b'ok', )),
990
request.do_body(b'foo bar baz'))
992
branch.control_transport.get_bytes('branch.conf'),
997
class TestSmartServerBranchRequestSetConfigOption(TestLockedBranch):
999
def test_value_name(self):
1000
branch = self.make_branch('.')
1001
request = smart_branch.SmartServerBranchRequestSetConfigOption(
1002
branch.controldir.root_transport)
1003
branch_token, repo_token = self.get_lock_tokens(branch)
1004
config = branch._get_config()
1005
result = request.execute(b'', branch_token, repo_token, b'bar', b'foo',
1007
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
1008
self.assertEqual('bar', config.get_option('foo'))
1012
def test_value_name_section(self):
1013
branch = self.make_branch('.')
1014
request = smart_branch.SmartServerBranchRequestSetConfigOption(
1015
branch.controldir.root_transport)
1016
branch_token, repo_token = self.get_lock_tokens(branch)
1017
config = branch._get_config()
1018
result = request.execute(b'', branch_token, repo_token, b'bar', b'foo',
1020
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
1021
self.assertEqual('bar', config.get_option('foo', 'gam'))
1026
class TestSmartServerBranchRequestSetConfigOptionDict(TestLockedBranch):
1029
TestLockedBranch.setUp(self)
1030
# A dict with non-ascii keys and values to exercise unicode
1032
self.encoded_value_dict = (
1033
b'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde')
1035
'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
1037
def test_value_name(self):
1038
branch = self.make_branch('.')
1039
request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
1040
branch.controldir.root_transport)
1041
branch_token, repo_token = self.get_lock_tokens(branch)
1042
config = branch._get_config()
1043
result = request.execute(b'', branch_token, repo_token,
1044
self.encoded_value_dict, b'foo', b'')
1045
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
1046
self.assertEqual(self.value_dict, config.get_option('foo'))
1050
def test_value_name_section(self):
1051
branch = self.make_branch('.')
1052
request = smart_branch.SmartServerBranchRequestSetConfigOptionDict(
1053
branch.controldir.root_transport)
1054
branch_token, repo_token = self.get_lock_tokens(branch)
1055
config = branch._get_config()
1056
result = request.execute(b'', branch_token, repo_token,
1057
self.encoded_value_dict, b'foo', b'gam')
1058
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), result)
1059
self.assertEqual(self.value_dict, config.get_option('foo', 'gam'))
1064
class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):
1065
# Only called when the branch format and tags match [yay factory
1066
# methods] so only need to test straight forward cases.
1068
def test_set_bytes(self):
1069
base_branch = self.make_branch('base')
1070
tag_bytes = base_branch._get_tags_bytes()
1071
# get_lock_tokens takes out a lock.
1072
branch_token, repo_token = self.get_lock_tokens(base_branch)
1073
request = smart_branch.SmartServerBranchSetTagsBytes(
1074
self.get_transport())
1075
response = request.execute(b'base', branch_token, repo_token)
1076
self.assertEqual(None, response)
1077
response = request.do_chunk(tag_bytes)
1078
self.assertEqual(None, response)
1079
response = request.do_end()
1081
smart_req.SuccessfulSmartServerResponse(()), response)
1082
base_branch.unlock()
1084
def test_lock_failed(self):
1085
base_branch = self.make_branch('base')
1086
base_branch.lock_write()
1087
tag_bytes = base_branch._get_tags_bytes()
1088
request = smart_branch.SmartServerBranchSetTagsBytes(
1089
self.get_transport())
1090
self.assertRaises(errors.TokenMismatch, request.execute,
1091
b'base', b'wrong token', b'wrong token')
1092
# The request handler will keep processing the message parts, so even
1093
# if the request fails immediately do_chunk and do_end are still
1095
request.do_chunk(tag_bytes)
1097
base_branch.unlock()
1100
class SetLastRevisionTestBase(TestLockedBranch):
1101
"""Base test case for verbs that implement set_last_revision."""
1104
super(SetLastRevisionTestBase, self).setUp()
1105
backing_transport = self.get_transport()
1106
self.request = self.request_class(backing_transport)
1107
self.tree = self.make_branch_and_memory_tree('.')
1109
def lock_branch(self):
1110
return self.get_lock_tokens(self.tree.branch)
1112
def unlock_branch(self):
1113
self.tree.branch.unlock()
1115
def set_last_revision(self, revision_id, revno):
1116
branch_token, repo_token = self.lock_branch()
1117
response = self._set_last_revision(
1118
revision_id, revno, branch_token, repo_token)
1119
self.unlock_branch()
1122
def assertRequestSucceeds(self, revision_id, revno):
1123
response = self.set_last_revision(revision_id, revno)
1124
self.assertEqual(smart_req.SuccessfulSmartServerResponse((b'ok',)),
1128
class TestSetLastRevisionVerbMixin(object):
1129
"""Mixin test case for verbs that implement set_last_revision."""
1131
def test_set_null_to_null(self):
1132
"""An empty branch can have its last revision set to b'null:'."""
1133
self.assertRequestSucceeds(b'null:', 0)
1135
def test_NoSuchRevision(self):
1136
"""If the revision_id is not present, the verb returns NoSuchRevision.
1138
revision_id = b'non-existent revision'
1140
smart_req.FailedSmartServerResponse(
1141
(b'NoSuchRevision', revision_id)),
1142
self.set_last_revision(revision_id, 1))
1144
def make_tree_with_two_commits(self):
1145
self.tree.lock_write()
1147
rev_id_utf8 = u'\xc8'.encode('utf-8')
1148
self.tree.commit('1st commit', rev_id=rev_id_utf8)
1149
self.tree.commit('2nd commit', rev_id=b'rev-2')
1152
def test_branch_last_revision_info_is_updated(self):
1153
"""A branch's tip can be set to a revision that is present in its
1156
# Make a branch with an empty revision history, but two revisions in
1158
self.make_tree_with_two_commits()
1159
rev_id_utf8 = u'\xc8'.encode('utf-8')
1160
self.tree.branch.set_last_revision_info(0, b'null:')
1162
(0, b'null:'), self.tree.branch.last_revision_info())
1163
# We can update the branch to a revision that is present in the
1165
self.assertRequestSucceeds(rev_id_utf8, 1)
1167
(1, rev_id_utf8), self.tree.branch.last_revision_info())
1169
def test_branch_last_revision_info_rewind(self):
1170
"""A branch's tip can be set to a revision that is an ancestor of the
1173
self.make_tree_with_two_commits()
1174
rev_id_utf8 = u'\xc8'.encode('utf-8')
1176
(2, b'rev-2'), self.tree.branch.last_revision_info())
1177
self.assertRequestSucceeds(rev_id_utf8, 1)
1179
(1, rev_id_utf8), self.tree.branch.last_revision_info())
1181
def test_TipChangeRejected(self):
1182
"""If a pre_change_branch_tip hook raises TipChangeRejected, the verb
1183
returns TipChangeRejected.
1185
rejection_message = u'rejection message\N{INTERROBANG}'
1187
def hook_that_rejects(params):
1188
raise errors.TipChangeRejected(rejection_message)
1189
_mod_branch.Branch.hooks.install_named_hook(
1190
'pre_change_branch_tip', hook_that_rejects, None)
1192
smart_req.FailedSmartServerResponse(
1193
(b'TipChangeRejected', rejection_message.encode('utf-8'))),
1194
self.set_last_revision(b'null:', 0))
1197
class TestSmartServerBranchRequestSetLastRevision(
1198
SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
1199
"""Tests for Branch.set_last_revision verb."""
1201
request_class = smart_branch.SmartServerBranchRequestSetLastRevision
1203
def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
1204
return self.request.execute(
1205
b'', branch_token, repo_token, revision_id)
1208
class TestSmartServerBranchRequestSetLastRevisionInfo(
1209
SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
1210
"""Tests for Branch.set_last_revision_info verb."""
1212
request_class = smart_branch.SmartServerBranchRequestSetLastRevisionInfo
1214
def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
1215
return self.request.execute(
1216
b'', branch_token, repo_token, revno, revision_id)
1218
def test_NoSuchRevision(self):
1219
"""Branch.set_last_revision_info does not have to return
1220
NoSuchRevision if the revision_id is absent.
1222
raise tests.TestNotApplicable()
1225
class TestSmartServerBranchRequestSetLastRevisionEx(
1226
SetLastRevisionTestBase, TestSetLastRevisionVerbMixin):
1227
"""Tests for Branch.set_last_revision_ex verb."""
1229
request_class = smart_branch.SmartServerBranchRequestSetLastRevisionEx
1231
def _set_last_revision(self, revision_id, revno, branch_token, repo_token):
1232
return self.request.execute(
1233
b'', branch_token, repo_token, revision_id, 0, 0)
1235
def assertRequestSucceeds(self, revision_id, revno):
1236
response = self.set_last_revision(revision_id, revno)
1238
smart_req.SuccessfulSmartServerResponse(
1239
(b'ok', revno, revision_id)),
1242
def test_branch_last_revision_info_rewind(self):
1243
"""A branch's tip can be set to a revision that is an ancestor of the
1244
current tip, but only if allow_overwrite_descendant is passed.
1246
self.make_tree_with_two_commits()
1247
rev_id_utf8 = u'\xc8'.encode('utf-8')
1249
(2, b'rev-2'), self.tree.branch.last_revision_info())
1250
# If allow_overwrite_descendant flag is 0, then trying to set the tip
1251
# to an older revision ID has no effect.
1252
branch_token, repo_token = self.lock_branch()
1253
response = self.request.execute(
1254
b'', branch_token, repo_token, rev_id_utf8, 0, 0)
1256
smart_req.SuccessfulSmartServerResponse((b'ok', 2, b'rev-2')),
1259
(2, b'rev-2'), self.tree.branch.last_revision_info())
1261
# If allow_overwrite_descendant flag is 1, then setting the tip to an
1263
response = self.request.execute(
1264
b'', branch_token, repo_token, rev_id_utf8, 0, 1)
1266
smart_req.SuccessfulSmartServerResponse((b'ok', 1, rev_id_utf8)),
1268
self.unlock_branch()
1270
(1, rev_id_utf8), self.tree.branch.last_revision_info())
1272
def make_branch_with_divergent_history(self):
1273
"""Make a branch with divergent history in its repo.
1275
The branch's tip will be 'child-2', and the repo will also contain
1276
'child-1', which diverges from a common base revision.
1278
self.tree.lock_write()
1280
self.tree.commit('1st commit')
1281
revno_1, revid_1 = self.tree.branch.last_revision_info()
1282
self.tree.commit('2nd commit', rev_id=b'child-1')
1283
# Undo the second commit
1284
self.tree.branch.set_last_revision_info(revno_1, revid_1)
1285
self.tree.set_parent_ids([revid_1])
1286
# Make a new second commit, child-2. child-2 has diverged from
1288
self.tree.commit('2nd commit', rev_id=b'child-2')
1291
def test_not_allow_diverged(self):
1292
"""If allow_diverged is not passed, then setting a divergent history
1293
returns a Diverged error.
1295
self.make_branch_with_divergent_history()
1297
smart_req.FailedSmartServerResponse((b'Diverged',)),
1298
self.set_last_revision(b'child-1', 2))
1299
# The branch tip was not changed.
1300
self.assertEqual(b'child-2', self.tree.branch.last_revision())
1302
def test_allow_diverged(self):
1303
"""If allow_diverged is passed, then setting a divergent history
1306
self.make_branch_with_divergent_history()
1307
branch_token, repo_token = self.lock_branch()
1308
response = self.request.execute(
1309
b'', branch_token, repo_token, b'child-1', 1, 0)
1311
smart_req.SuccessfulSmartServerResponse((b'ok', 2, b'child-1')),
1313
self.unlock_branch()
1314
# The branch tip was changed.
1315
self.assertEqual(b'child-1', self.tree.branch.last_revision())
1318
class TestSmartServerBranchBreakLock(tests.TestCaseWithMemoryTransport):
1320
def test_lock_to_break(self):
1321
base_branch = self.make_branch('base')
1322
request = smart_branch.SmartServerBranchBreakLock(
1323
self.get_transport())
1324
base_branch.lock_write()
1326
smart_req.SuccessfulSmartServerResponse((b'ok', ), None),
1327
request.execute(b'base'))
1329
def test_nothing_to_break(self):
1330
self.make_branch('base')
1331
request = smart_branch.SmartServerBranchBreakLock(
1332
self.get_transport())
1334
smart_req.SuccessfulSmartServerResponse((b'ok', ), None),
1335
request.execute(b'base'))
1338
class TestSmartServerBranchRequestGetParent(tests.TestCaseWithMemoryTransport):
1340
def test_get_parent_none(self):
1341
self.make_branch('base')
1342
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
1343
response = request.execute(b'base')
1345
smart_req.SuccessfulSmartServerResponse((b'',)), response)
1347
def test_get_parent_something(self):
1348
base_branch = self.make_branch('base')
1349
base_branch.set_parent(self.get_url('foo'))
1350
request = smart_branch.SmartServerBranchGetParent(self.get_transport())
1351
response = request.execute(b'base')
1353
smart_req.SuccessfulSmartServerResponse((b"../foo",)),
1357
class TestSmartServerBranchRequestSetParent(TestLockedBranch):
1359
def test_set_parent_none(self):
1360
branch = self.make_branch('base', format="1.9")
1362
branch._set_parent_location('foo')
1364
request = smart_branch.SmartServerBranchRequestSetParentLocation(
1365
self.get_transport())
1366
branch_token, repo_token = self.get_lock_tokens(branch)
1368
response = request.execute(b'base', branch_token, repo_token, b'')
1371
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1372
# Refresh branch as SetParentLocation modified it
1373
branch = branch.controldir.open_branch()
1374
self.assertEqual(None, branch.get_parent())
1376
def test_set_parent_something(self):
1377
branch = self.make_branch('base', format="1.9")
1378
request = smart_branch.SmartServerBranchRequestSetParentLocation(
1379
self.get_transport())
1380
branch_token, repo_token = self.get_lock_tokens(branch)
1382
response = request.execute(b'base', branch_token, repo_token,
1386
self.assertEqual(smart_req.SuccessfulSmartServerResponse(()), response)
1387
refreshed = _mod_branch.Branch.open(branch.base)
1388
self.assertEqual('http://bar/', refreshed.get_parent())
1391
class TestSmartServerBranchRequestGetTagsBytes(
1392
tests.TestCaseWithMemoryTransport):
1393
# Only called when the branch format and tags match [yay factory
1394
# methods] so only need to test straight forward cases.
1396
def test_get_bytes(self):
1397
self.make_branch('base')
1398
request = smart_branch.SmartServerBranchGetTagsBytes(
1399
self.get_transport())
1400
response = request.execute(b'base')
1402
smart_req.SuccessfulSmartServerResponse((b'',)), response)
1405
class TestSmartServerBranchRequestGetStackedOnURL(
1406
tests.TestCaseWithMemoryTransport):
1408
def test_get_stacked_on_url(self):
1409
self.make_branch('base', format='1.6')
1410
stacked_branch = self.make_branch('stacked', format='1.6')
1411
# typically should be relative
1412
stacked_branch.set_stacked_on_url('../base')
1413
request = smart_branch.SmartServerBranchRequestGetStackedOnURL(
1414
self.get_transport())
1415
response = request.execute(b'stacked')
1417
smart_req.SmartServerResponse((b'ok', b'../base')),
1421
class TestSmartServerBranchRequestLockWrite(TestLockedBranch):
1423
def test_lock_write_on_unlocked_branch(self):
1424
backing = self.get_transport()
1425
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1426
branch = self.make_branch('.', format='knit')
1427
repository = branch.repository
1428
response = request.execute(b'')
1429
branch_nonce = branch.control_files._lock.peek().get('nonce')
1430
repository_nonce = repository.control_files._lock.peek().get('nonce')
1431
self.assertEqual(smart_req.SmartServerResponse(
1432
(b'ok', branch_nonce, repository_nonce)),
1434
# The branch (and associated repository) is now locked. Verify that
1435
# with a new branch object.
1436
new_branch = repository.controldir.open_branch()
1437
self.assertRaises(errors.LockContention, new_branch.lock_write)
1439
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1440
response = request.execute(b'', branch_nonce, repository_nonce)
1442
def test_lock_write_on_locked_branch(self):
1443
backing = self.get_transport()
1444
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1445
branch = self.make_branch('.')
1446
branch_token = branch.lock_write().token
1447
branch.leave_lock_in_place()
1449
response = request.execute(b'')
1451
smart_req.SmartServerResponse((b'LockContention',)), response)
1453
branch.lock_write(branch_token)
1454
branch.dont_leave_lock_in_place()
1457
def test_lock_write_with_tokens_on_locked_branch(self):
1458
backing = self.get_transport()
1459
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1460
branch = self.make_branch('.', format='knit')
1461
branch_token, repo_token = self.get_lock_tokens(branch)
1462
branch.leave_lock_in_place()
1463
branch.repository.leave_lock_in_place()
1465
response = request.execute(b'',
1466
branch_token, repo_token)
1468
smart_req.SmartServerResponse((b'ok', branch_token, repo_token)),
1471
branch.repository.lock_write(repo_token)
1472
branch.repository.dont_leave_lock_in_place()
1473
branch.repository.unlock()
1474
branch.lock_write(branch_token)
1475
branch.dont_leave_lock_in_place()
1478
def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
1479
backing = self.get_transport()
1480
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1481
branch = self.make_branch('.', format='knit')
1482
branch_token, repo_token = self.get_lock_tokens(branch)
1483
branch.leave_lock_in_place()
1484
branch.repository.leave_lock_in_place()
1486
response = request.execute(b'',
1487
branch_token + b'xxx', repo_token)
1489
smart_req.SmartServerResponse((b'TokenMismatch',)), response)
1491
branch.repository.lock_write(repo_token)
1492
branch.repository.dont_leave_lock_in_place()
1493
branch.repository.unlock()
1494
branch.lock_write(branch_token)
1495
branch.dont_leave_lock_in_place()
1498
def test_lock_write_on_locked_repo(self):
1499
backing = self.get_transport()
1500
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1501
branch = self.make_branch('.', format='knit')
1502
repo = branch.repository
1503
repo_token = repo.lock_write().repository_token
1504
repo.leave_lock_in_place()
1506
response = request.execute(b'')
1508
smart_req.SmartServerResponse((b'LockContention',)), response)
1510
repo.lock_write(repo_token)
1511
repo.dont_leave_lock_in_place()
1514
def test_lock_write_on_readonly_transport(self):
1515
backing = self.get_readonly_transport()
1516
request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1517
self.make_branch('.')
1518
root = self.get_transport().clone('/')
1519
path = urlutils.relative_url(root.base, self.get_transport().base)
1520
response = request.execute(path.encode('utf-8'))
1521
error_name, lock_str, why_str = response.args
1522
self.assertFalse(response.is_successful())
1523
self.assertEqual(b'LockFailed', error_name)
1526
class TestSmartServerBranchRequestGetPhysicalLockStatus(TestLockedBranch):
1528
def test_true(self):
1529
backing = self.get_transport()
1530
request = smart_branch.SmartServerBranchRequestGetPhysicalLockStatus(
1532
branch = self.make_branch('.')
1533
branch_token, repo_token = self.get_lock_tokens(branch)
1534
self.assertEqual(True, branch.get_physical_lock_status())
1535
response = request.execute(b'')
1537
smart_req.SmartServerResponse((b'yes',)), response)
1540
def test_false(self):
1541
backing = self.get_transport()
1542
request = smart_branch.SmartServerBranchRequestGetPhysicalLockStatus(
1544
branch = self.make_branch('.')
1545
self.assertEqual(False, branch.get_physical_lock_status())
1546
response = request.execute(b'')
1548
smart_req.SmartServerResponse((b'no',)), response)
1551
class TestSmartServerBranchRequestUnlock(TestLockedBranch):
1553
def test_unlock_on_locked_branch_and_repo(self):
1554
backing = self.get_transport()
1555
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1556
branch = self.make_branch('.', format='knit')
1558
branch_token, repo_token = self.get_lock_tokens(branch)
1559
# Unlock the branch (and repo) object, leaving the physical locks
1561
branch.leave_lock_in_place()
1562
branch.repository.leave_lock_in_place()
1564
response = request.execute(b'',
1565
branch_token, repo_token)
1567
smart_req.SmartServerResponse((b'ok',)), response)
1568
# The branch is now unlocked. Verify that with a new branch
1570
new_branch = branch.controldir.open_branch()
1571
new_branch.lock_write()
1574
def test_unlock_on_unlocked_branch_unlocked_repo(self):
1575
backing = self.get_transport()
1576
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1577
self.make_branch('.', format='knit')
1578
response = request.execute(
1579
b'', b'branch token', b'repo token')
1581
smart_req.SmartServerResponse((b'TokenMismatch',)), response)
1583
def test_unlock_on_unlocked_branch_locked_repo(self):
1584
backing = self.get_transport()
1585
request = smart_branch.SmartServerBranchRequestUnlock(backing)
1586
branch = self.make_branch('.', format='knit')
1587
# Lock the repository.
1588
repo_token = branch.repository.lock_write().repository_token
1589
branch.repository.leave_lock_in_place()
1590
branch.repository.unlock()
1591
# Issue branch lock_write request on the unlocked branch (with locked
1593
response = request.execute(b'', b'branch token', repo_token)
1595
smart_req.SmartServerResponse((b'TokenMismatch',)), response)
1597
branch.repository.lock_write(repo_token)
1598
branch.repository.dont_leave_lock_in_place()
1599
branch.repository.unlock()
1602
class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport):
1604
def test_no_repository(self):
1605
"""Raise NoRepositoryPresent when there is a bzrdir and no repo."""
1606
# we test this using a shared repository above the named path,
1607
# thus checking the right search logic is used - that is, that
1608
# its the exact path being looked at and the server is not
1610
backing = self.get_transport()
1611
request = smart_repo.SmartServerRepositoryRequest(backing)
1612
self.make_repository('.', shared=True)
1613
self.make_controldir('subdir')
1614
self.assertRaises(errors.NoRepositoryPresent,
1615
request.execute, b'subdir')
1618
class TestSmartServerRepositoryAddSignatureText(
1619
tests.TestCaseWithMemoryTransport):
1621
def test_add_text(self):
1622
backing = self.get_transport()
1623
request = smart_repo.SmartServerRepositoryAddSignatureText(backing)
1624
tree = self.make_branch_and_memory_tree('.')
1625
write_token = tree.lock_write()
1626
self.addCleanup(tree.unlock)
1628
tree.commit("Message", rev_id=b'rev1')
1629
tree.branch.repository.start_write_group()
1630
write_group_tokens = tree.branch.repository.suspend_write_group()
1632
None, request.execute(
1633
b'', write_token, b'rev1',
1634
*[token.encode('utf-8') for token in write_group_tokens]))
1635
response = request.do_body(b'somesignature')
1636
self.assertTrue(response.is_successful())
1637
self.assertEqual(response.args[0], b'ok')
1638
write_group_tokens = [token.decode('utf-8')
1639
for token in response.args[1:]]
1640
tree.branch.repository.resume_write_group(write_group_tokens)
1641
tree.branch.repository.commit_write_group()
1643
self.assertEqual(b"somesignature",
1644
tree.branch.repository.get_signature_text(b"rev1"))
1647
class TestSmartServerRepositoryAllRevisionIds(
1648
tests.TestCaseWithMemoryTransport):
1650
def test_empty(self):
1651
"""An empty body should be returned for an empty repository."""
1652
backing = self.get_transport()
1653
request = smart_repo.SmartServerRepositoryAllRevisionIds(backing)
1654
self.make_repository('.')
1656
smart_req.SuccessfulSmartServerResponse((b"ok", ), b""),
1657
request.execute(b''))
1659
def test_some_revisions(self):
1660
"""An empty body should be returned for an empty repository."""
1661
backing = self.get_transport()
1662
request = smart_repo.SmartServerRepositoryAllRevisionIds(backing)
1663
tree = self.make_branch_and_memory_tree('.')
1666
tree.commit(rev_id=b'origineel', message="message")
1667
tree.commit(rev_id=b'nog-een-revisie', message="message")
1670
request.execute(b''),
1671
[smart_req.SuccessfulSmartServerResponse(
1672
(b"ok", ), b"origineel\nnog-een-revisie"),
1673
smart_req.SuccessfulSmartServerResponse(
1674
(b"ok", ), b"nog-een-revisie\norigineel")])
1677
class TestSmartServerRepositoryBreakLock(tests.TestCaseWithMemoryTransport):
1679
def test_lock_to_break(self):
1680
backing = self.get_transport()
1681
request = smart_repo.SmartServerRepositoryBreakLock(backing)
1682
tree = self.make_branch_and_memory_tree('.')
1683
tree.branch.repository.lock_write()
1685
smart_req.SuccessfulSmartServerResponse((b'ok', ), None),
1686
request.execute(b''))
1688
def test_nothing_to_break(self):
1689
backing = self.get_transport()
1690
request = smart_repo.SmartServerRepositoryBreakLock(backing)
1691
self.make_branch_and_memory_tree('.')
1693
smart_req.SuccessfulSmartServerResponse((b'ok', ), None),
1694
request.execute(b''))
1697
class TestSmartServerRepositoryGetParentMap(tests.TestCaseWithMemoryTransport):
1699
def test_trivial_bzipped(self):
1700
# This tests that the wire encoding is actually bzipped
1701
backing = self.get_transport()
1702
request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1703
self.make_branch_and_memory_tree('.')
1705
self.assertEqual(None,
1706
request.execute(b'', b'missing-id'))
1707
# Note that it returns a body that is bzipped.
1709
smart_req.SuccessfulSmartServerResponse(
1710
(b'ok', ), bz2.compress(b'')),
1711
request.do_body(b'\n\n0\n'))
1713
def test_trivial_include_missing(self):
1714
backing = self.get_transport()
1715
request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1716
self.make_branch_and_memory_tree('.')
1719
None, request.execute(b'', b'missing-id', b'include-missing:'))
1721
smart_req.SuccessfulSmartServerResponse(
1722
(b'ok', ), bz2.compress(b'missing:missing-id')),
1723
request.do_body(b'\n\n0\n'))
1726
class TestSmartServerRepositoryGetRevisionGraph(
1727
tests.TestCaseWithMemoryTransport):
1729
def test_none_argument(self):
1730
backing = self.get_transport()
1731
request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
1732
tree = self.make_branch_and_memory_tree('.')
1735
r1 = tree.commit('1st commit')
1736
r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1739
# the lines of revision_id->revision_parent_list has no guaranteed
1740
# order coming out of a dict, so sort both our test and response
1741
lines = sorted([b' '.join([r2, r1]), r1])
1742
response = request.execute(b'', b'')
1743
response.body = b'\n'.join(sorted(response.body.split(b'\n')))
1746
smart_req.SmartServerResponse((b'ok', ), b'\n'.join(lines)),
1749
def test_specific_revision_argument(self):
1750
backing = self.get_transport()
1751
request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
1752
tree = self.make_branch_and_memory_tree('.')
1755
rev_id_utf8 = u'\xc9'.encode('utf-8')
1756
tree.commit('1st commit', rev_id=rev_id_utf8)
1757
tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1760
self.assertEqual(smart_req.SmartServerResponse((b'ok', ), rev_id_utf8),
1761
request.execute(b'', rev_id_utf8))
1763
def test_no_such_revision(self):
1764
backing = self.get_transport()
1765
request = smart_repo.SmartServerRepositoryGetRevisionGraph(backing)
1766
tree = self.make_branch_and_memory_tree('.')
1769
tree.commit('1st commit')
1772
# Note that it still returns body (of zero bytes).
1773
self.assertEqual(smart_req.SmartServerResponse(
1774
(b'nosuchrevision', b'missingrevision', ), b''),
1775
request.execute(b'', b'missingrevision'))
1778
class TestSmartServerRepositoryGetRevIdForRevno(
1779
tests.TestCaseWithMemoryTransport):
1781
def test_revno_found(self):
1782
backing = self.get_transport()
1783
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1784
tree = self.make_branch_and_memory_tree('.')
1787
rev1_id_utf8 = u'\xc8'.encode('utf-8')
1788
rev2_id_utf8 = u'\xc9'.encode('utf-8')
1789
tree.commit('1st commit', rev_id=rev1_id_utf8)
1790
tree.commit('2nd commit', rev_id=rev2_id_utf8)
1793
self.assertEqual(smart_req.SmartServerResponse((b'ok', rev1_id_utf8)),
1794
request.execute(b'', 1, (2, rev2_id_utf8)))
1796
def test_known_revid_missing(self):
1797
backing = self.get_transport()
1798
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1799
self.make_repository('.')
1801
smart_req.FailedSmartServerResponse((b'nosuchrevision', b'ghost')),
1802
request.execute(b'', 1, (2, b'ghost')))
1804
def test_history_incomplete(self):
1805
backing = self.get_transport()
1806
request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1807
parent = self.make_branch_and_memory_tree('parent', format='1.9')
1809
parent.add([''], [b'TREE_ROOT'])
1810
parent.commit(message='first commit')
1811
r2 = parent.commit(message='second commit')
1813
local = self.make_branch_and_memory_tree('local', format='1.9')
1814
local.branch.pull(parent.branch)
1815
local.set_parent_ids([r2])
1816
r3 = local.commit(message='local commit')
1817
local.branch.create_clone_on_transport(
1818
self.get_transport('stacked'), stacked_on=self.get_url('parent'))
1820
smart_req.SmartServerResponse((b'history-incomplete', 2, r2)),
1821
request.execute(b'stacked', 1, (3, r3)))
1824
class TestSmartServerRepositoryIterRevisions(
1825
tests.TestCaseWithMemoryTransport):
1827
def test_basic(self):
1828
backing = self.get_transport()
1829
request = smart_repo.SmartServerRepositoryIterRevisions(backing)
1830
tree = self.make_branch_and_memory_tree('.', format='2a')
1833
tree.commit('1st commit', rev_id=b"rev1")
1834
tree.commit('2nd commit', rev_id=b"rev2")
1837
self.assertIs(None, request.execute(b''))
1838
response = request.do_body(b"rev1\nrev2")
1839
self.assertTrue(response.is_successful())
1840
# Format 2a uses serializer format 10
1841
self.assertEqual(response.args, (b"ok", b"10"))
1843
self.addCleanup(tree.branch.lock_read().unlock)
1844
entries = [zlib.compress(record.get_bytes_as("fulltext")) for record in
1845
tree.branch.repository.revisions.get_record_stream(
1846
[(b"rev1", ), (b"rev2", )], "unordered", True)]
1848
contents = b"".join(response.body_stream)
1849
self.assertTrue(contents in (
1850
b"".join([entries[0], entries[1]]),
1851
b"".join([entries[1], entries[0]])))
1853
def test_missing(self):
1854
backing = self.get_transport()
1855
request = smart_repo.SmartServerRepositoryIterRevisions(backing)
1856
self.make_branch_and_memory_tree('.', format='2a')
1858
self.assertIs(None, request.execute(b''))
1859
response = request.do_body(b"rev1\nrev2")
1860
self.assertTrue(response.is_successful())
1861
# Format 2a uses serializer format 10
1862
self.assertEqual(response.args, (b"ok", b"10"))
1864
contents = b"".join(response.body_stream)
1865
self.assertEqual(contents, b"")
1868
class GetStreamTestBase(tests.TestCaseWithMemoryTransport):
1870
def make_two_commit_repo(self):
1871
tree = self.make_branch_and_memory_tree('.')
1874
r1 = tree.commit('1st commit')
1875
r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1877
repo = tree.branch.repository
1881
class TestSmartServerRepositoryGetStream(GetStreamTestBase):
1883
def test_ancestry_of(self):
1884
"""The search argument may be a 'ancestry-of' some heads'."""
1885
backing = self.get_transport()
1886
request = smart_repo.SmartServerRepositoryGetStream(backing)
1887
repo, r1, r2 = self.make_two_commit_repo()
1888
fetch_spec = [b'ancestry-of', r2]
1889
lines = b'\n'.join(fetch_spec)
1890
request.execute(b'', repo._format.network_name())
1891
response = request.do_body(lines)
1892
self.assertEqual((b'ok',), response.args)
1893
stream_bytes = b''.join(response.body_stream)
1894
self.assertStartsWith(stream_bytes, b'Bazaar pack format 1')
1896
def test_search(self):
1897
"""The search argument may be a 'search' of some explicit keys."""
1898
backing = self.get_transport()
1899
request = smart_repo.SmartServerRepositoryGetStream(backing)
1900
repo, r1, r2 = self.make_two_commit_repo()
1901
fetch_spec = [b'search', r1 + b' ' + r2, b'null:', b'2']
1902
lines = b'\n'.join(fetch_spec)
1903
request.execute(b'', repo._format.network_name())
1904
response = request.do_body(lines)
1905
self.assertEqual((b'ok',), response.args)
1906
stream_bytes = b''.join(response.body_stream)
1907
self.assertStartsWith(stream_bytes, b'Bazaar pack format 1')
1909
def test_search_everything(self):
1910
"""A search of 'everything' returns a stream."""
1911
backing = self.get_transport()
1912
request = smart_repo.SmartServerRepositoryGetStream_1_19(backing)
1913
repo, r1, r2 = self.make_two_commit_repo()
1914
serialised_fetch_spec = b'everything'
1915
request.execute(b'', repo._format.network_name())
1916
response = request.do_body(serialised_fetch_spec)
1917
self.assertEqual((b'ok',), response.args)
1918
stream_bytes = b''.join(response.body_stream)
1919
self.assertStartsWith(stream_bytes, b'Bazaar pack format 1')
1922
class TestSmartServerRequestHasRevision(tests.TestCaseWithMemoryTransport):
1924
def test_missing_revision(self):
1925
"""For a missing revision, ('no', ) is returned."""
1926
backing = self.get_transport()
1927
request = smart_repo.SmartServerRequestHasRevision(backing)
1928
self.make_repository('.')
1929
self.assertEqual(smart_req.SmartServerResponse((b'no', )),
1930
request.execute(b'', b'revid'))
1932
def test_present_revision(self):
1933
"""For a present revision, ('yes', ) is returned."""
1934
backing = self.get_transport()
1935
request = smart_repo.SmartServerRequestHasRevision(backing)
1936
tree = self.make_branch_and_memory_tree('.')
1939
rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1940
tree.commit('a commit', rev_id=rev_id_utf8)
1942
self.assertTrue(tree.branch.repository.has_revision(rev_id_utf8))
1943
self.assertEqual(smart_req.SmartServerResponse((b'yes', )),
1944
request.execute(b'', rev_id_utf8))
1947
class TestSmartServerRepositoryIterFilesBytes(tests.TestCaseWithTransport):
1949
def test_single(self):
1950
backing = self.get_transport()
1951
request = smart_repo.SmartServerRepositoryIterFilesBytes(backing)
1952
t = self.make_branch_and_tree('.')
1953
self.addCleanup(t.lock_write().unlock)
1954
self.build_tree_contents([("file", b"somecontents")])
1955
t.add(["file"], [b"thefileid"])
1956
t.commit(rev_id=b'somerev', message="add file")
1957
self.assertIs(None, request.execute(b''))
1958
response = request.do_body(b"thefileid\0somerev\n")
1959
self.assertTrue(response.is_successful())
1960
self.assertEqual(response.args, (b"ok", ))
1961
self.assertEqual(b"".join(response.body_stream),
1962
b"ok\x000\n" + zlib.compress(b"somecontents"))
1964
def test_missing(self):
1965
backing = self.get_transport()
1966
request = smart_repo.SmartServerRepositoryIterFilesBytes(backing)
1967
t = self.make_branch_and_tree('.')
1968
self.addCleanup(t.lock_write().unlock)
1969
self.assertIs(None, request.execute(b''))
1970
response = request.do_body(b"thefileid\0revision\n")
1971
self.assertTrue(response.is_successful())
1972
self.assertEqual(response.args, (b"ok", ))
1973
self.assertEqual(b"".join(response.body_stream),
1974
b"absent\x00thefileid\x00revision\x000\n")
1977
class TestSmartServerRequestHasSignatureForRevisionId(
1978
tests.TestCaseWithMemoryTransport):
1980
def test_missing_revision(self):
1981
"""For a missing revision, NoSuchRevision is returned."""
1982
backing = self.get_transport()
1983
request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
1985
self.make_repository('.')
1987
smart_req.FailedSmartServerResponse(
1988
(b'nosuchrevision', b'revid'), None),
1989
request.execute(b'', b'revid'))
1991
def test_missing_signature(self):
1992
"""For a missing signature, ('no', ) is returned."""
1993
backing = self.get_transport()
1994
request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
1996
tree = self.make_branch_and_memory_tree('.')
1999
tree.commit('a commit', rev_id=b'A')
2001
self.assertTrue(tree.branch.repository.has_revision(b'A'))
2002
self.assertEqual(smart_req.SmartServerResponse((b'no', )),
2003
request.execute(b'', b'A'))
2005
def test_present_signature(self):
2006
"""For a present signature, ('yes', ) is returned."""
2007
backing = self.get_transport()
2008
request = smart_repo.SmartServerRequestHasSignatureForRevisionId(
2010
strategy = gpg.LoopbackGPGStrategy(None)
2011
tree = self.make_branch_and_memory_tree('.')
2014
tree.commit('a commit', rev_id=b'A')
2015
tree.branch.repository.start_write_group()
2016
tree.branch.repository.sign_revision(b'A', strategy)
2017
tree.branch.repository.commit_write_group()
2019
self.assertTrue(tree.branch.repository.has_revision(b'A'))
2020
self.assertEqual(smart_req.SmartServerResponse((b'yes', )),
2021
request.execute(b'', b'A'))
2024
class TestSmartServerRepositoryGatherStats(tests.TestCaseWithMemoryTransport):
2026
def test_empty_revid(self):
2027
"""With an empty revid, we get only size an number and revisions"""
2028
backing = self.get_transport()
2029
request = smart_repo.SmartServerRepositoryGatherStats(backing)
2030
repository = self.make_repository('.')
2031
repository.gather_stats()
2032
expected_body = b'revisions: 0\n'
2034
smart_req.SmartServerResponse((b'ok', ), expected_body),
2035
request.execute(b'', b'', b'no'))
2037
def test_revid_with_committers(self):
2038
"""For a revid we get more infos."""
2039
backing = self.get_transport()
2040
rev_id_utf8 = u'\xc8abc'.encode('utf-8')
2041
request = smart_repo.SmartServerRepositoryGatherStats(backing)
2042
tree = self.make_branch_and_memory_tree('.')
2045
# Let's build a predictable result
2046
tree.commit('a commit', timestamp=123456.2, timezone=3600)
2047
tree.commit('a commit', timestamp=654321.4, timezone=0,
2051
tree.branch.repository.gather_stats()
2052
expected_body = (b'firstrev: 123456.200 3600\n'
2053
b'latestrev: 654321.400 0\n'
2056
smart_req.SmartServerResponse((b'ok', ), expected_body),
2057
request.execute(b'', rev_id_utf8, b'no'))
2059
def test_not_empty_repository_with_committers(self):
2060
"""For a revid and requesting committers we get the whole thing."""
2061
backing = self.get_transport()
2062
rev_id_utf8 = u'\xc8abc'.encode('utf-8')
2063
request = smart_repo.SmartServerRepositoryGatherStats(backing)
2064
tree = self.make_branch_and_memory_tree('.')
2067
# Let's build a predictable result
2068
tree.commit('a commit', timestamp=123456.2, timezone=3600,
2070
tree.commit('a commit', timestamp=654321.4, timezone=0,
2071
committer='bar', rev_id=rev_id_utf8)
2073
tree.branch.repository.gather_stats()
2075
expected_body = (b'committers: 2\n'
2076
b'firstrev: 123456.200 3600\n'
2077
b'latestrev: 654321.400 0\n'
2080
smart_req.SmartServerResponse((b'ok', ), expected_body),
2081
request.execute(b'', rev_id_utf8, b'yes'))
2083
def test_unknown_revid(self):
2084
"""An unknown revision id causes a 'nosuchrevision' error."""
2085
backing = self.get_transport()
2086
request = smart_repo.SmartServerRepositoryGatherStats(backing)
2087
self.make_repository('.')
2089
smart_req.FailedSmartServerResponse(
2090
(b'nosuchrevision', b'mia'), None),
2091
request.execute(b'', b'mia', b'yes'))
2094
class TestSmartServerRepositoryIsShared(tests.TestCaseWithMemoryTransport):
2096
def test_is_shared(self):
2097
"""For a shared repository, ('yes', ) is returned."""
2098
backing = self.get_transport()
2099
request = smart_repo.SmartServerRepositoryIsShared(backing)
2100
self.make_repository('.', shared=True)
2101
self.assertEqual(smart_req.SmartServerResponse((b'yes', )),
2102
request.execute(b'', ))
2104
def test_is_not_shared(self):
2105
"""For a shared repository, ('no', ) is returned."""
2106
backing = self.get_transport()
2107
request = smart_repo.SmartServerRepositoryIsShared(backing)
2108
self.make_repository('.', shared=False)
2109
self.assertEqual(smart_req.SmartServerResponse((b'no', )),
2110
request.execute(b'', ))
2113
class TestSmartServerRepositoryGetRevisionSignatureText(
2114
tests.TestCaseWithMemoryTransport):
2116
def test_get_signature(self):
2117
backing = self.get_transport()
2118
request = smart_repo.SmartServerRepositoryGetRevisionSignatureText(
2120
bb = self.make_branch_builder('.')
2121
bb.build_commit(rev_id=b'A')
2122
repo = bb.get_branch().repository
2123
strategy = gpg.LoopbackGPGStrategy(None)
2124
self.addCleanup(repo.lock_write().unlock)
2125
repo.start_write_group()
2126
repo.sign_revision(b'A', strategy)
2127
repo.commit_write_group()
2129
b'-----BEGIN PSEUDO-SIGNED CONTENT-----\n' +
2130
Testament.from_revision(repo, b'A').as_short_text() +
2131
b'-----END PSEUDO-SIGNED CONTENT-----\n')
2133
smart_req.SmartServerResponse((b'ok', ), expected_body),
2134
request.execute(b'', b'A'))
2137
class TestSmartServerRepositoryMakeWorkingTrees(
2138
tests.TestCaseWithMemoryTransport):
2140
def test_make_working_trees(self):
2141
"""For a repository with working trees, ('yes', ) is returned."""
2142
backing = self.get_transport()
2143
request = smart_repo.SmartServerRepositoryMakeWorkingTrees(backing)
2144
r = self.make_repository('.')
2145
r.set_make_working_trees(True)
2146
self.assertEqual(smart_req.SmartServerResponse((b'yes', )),
2147
request.execute(b'', ))
2149
def test_is_not_shared(self):
2150
"""For a repository with working trees, ('no', ) is returned."""
2151
backing = self.get_transport()
2152
request = smart_repo.SmartServerRepositoryMakeWorkingTrees(backing)
2153
r = self.make_repository('.')
2154
r.set_make_working_trees(False)
2155
self.assertEqual(smart_req.SmartServerResponse((b'no', )),
2156
request.execute(b'', ))
2159
class TestSmartServerRepositoryLockWrite(tests.TestCaseWithMemoryTransport):
2161
def test_lock_write_on_unlocked_repo(self):
2162
backing = self.get_transport()
2163
request = smart_repo.SmartServerRepositoryLockWrite(backing)
2164
repository = self.make_repository('.', format='knit')
2165
response = request.execute(b'')
2166
nonce = repository.control_files._lock.peek().get('nonce')
2167
self.assertEqual(smart_req.SmartServerResponse(
2168
(b'ok', nonce)), response)
2169
# The repository is now locked. Verify that with a new repository
2171
new_repo = repository.controldir.open_repository()
2172
self.assertRaises(errors.LockContention, new_repo.lock_write)
2174
request = smart_repo.SmartServerRepositoryUnlock(backing)
2175
response = request.execute(b'', nonce)
2177
def test_lock_write_on_locked_repo(self):
2178
backing = self.get_transport()
2179
request = smart_repo.SmartServerRepositoryLockWrite(backing)
2180
repository = self.make_repository('.', format='knit')
2181
repo_token = repository.lock_write().repository_token
2182
repository.leave_lock_in_place()
2184
response = request.execute(b'')
2186
smart_req.SmartServerResponse((b'LockContention',)), response)
2188
repository.lock_write(repo_token)
2189
repository.dont_leave_lock_in_place()
2192
def test_lock_write_on_readonly_transport(self):
2193
backing = self.get_readonly_transport()
2194
request = smart_repo.SmartServerRepositoryLockWrite(backing)
2195
self.make_repository('.', format='knit')
2196
response = request.execute(b'')
2197
self.assertFalse(response.is_successful())
2198
self.assertEqual(b'LockFailed', response.args[0])
2201
class TestInsertStreamBase(tests.TestCaseWithMemoryTransport):
2203
def make_empty_byte_stream(self, repo):
2204
byte_stream = smart_repo._stream_to_byte_stream([], repo._format)
2205
return b''.join(byte_stream)
2208
class TestSmartServerRepositoryInsertStream(TestInsertStreamBase):
2210
def test_insert_stream_empty(self):
2211
backing = self.get_transport()
2212
request = smart_repo.SmartServerRepositoryInsertStream(backing)
2213
repository = self.make_repository('.')
2214
response = request.execute(b'', b'')
2215
self.assertEqual(None, response)
2216
response = request.do_chunk(self.make_empty_byte_stream(repository))
2217
self.assertEqual(None, response)
2218
response = request.do_end()
2219
self.assertEqual(smart_req.SmartServerResponse((b'ok', )), response)
2222
class TestSmartServerRepositoryInsertStreamLocked(TestInsertStreamBase):
2224
def test_insert_stream_empty(self):
2225
backing = self.get_transport()
2226
request = smart_repo.SmartServerRepositoryInsertStreamLocked(
2228
repository = self.make_repository('.', format='knit')
2229
lock_token = repository.lock_write().repository_token
2230
response = request.execute(b'', b'', lock_token)
2231
self.assertEqual(None, response)
2232
response = request.do_chunk(self.make_empty_byte_stream(repository))
2233
self.assertEqual(None, response)
2234
response = request.do_end()
2235
self.assertEqual(smart_req.SmartServerResponse((b'ok', )), response)
2238
def test_insert_stream_with_wrong_lock_token(self):
2239
backing = self.get_transport()
2240
request = smart_repo.SmartServerRepositoryInsertStreamLocked(
2242
repository = self.make_repository('.', format='knit')
2243
with repository.lock_write():
2245
errors.TokenMismatch, request.execute, b'', b'',
2249
class TestSmartServerRepositoryUnlock(tests.TestCaseWithMemoryTransport):
2251
def test_unlock_on_locked_repo(self):
2252
backing = self.get_transport()
2253
request = smart_repo.SmartServerRepositoryUnlock(backing)
2254
repository = self.make_repository('.', format='knit')
2255
token = repository.lock_write().repository_token
2256
repository.leave_lock_in_place()
2258
response = request.execute(b'', token)
2260
smart_req.SmartServerResponse((b'ok',)), response)
2261
# The repository is now unlocked. Verify that with a new repository
2263
new_repo = repository.controldir.open_repository()
2264
new_repo.lock_write()
2267
def test_unlock_on_unlocked_repo(self):
2268
backing = self.get_transport()
2269
request = smart_repo.SmartServerRepositoryUnlock(backing)
2270
self.make_repository('.', format='knit')
2271
response = request.execute(b'', b'some token')
2273
smart_req.SmartServerResponse((b'TokenMismatch',)), response)
2276
class TestSmartServerRepositoryGetPhysicalLockStatus(
2277
tests.TestCaseWithTransport):
2279
def test_with_write_lock(self):
2280
backing = self.get_transport()
2281
repo = self.make_repository('.')
2282
self.addCleanup(repo.lock_write().unlock)
2283
# lock_write() doesn't necessarily actually take a physical
2285
if repo.get_physical_lock_status():
2289
request_class = smart_repo.SmartServerRepositoryGetPhysicalLockStatus
2290
request = request_class(backing)
2291
self.assertEqual(smart_req.SuccessfulSmartServerResponse((expected,)),
2292
request.execute(b'', ))
2294
def test_without_write_lock(self):
2295
backing = self.get_transport()
2296
repo = self.make_repository('.')
2297
self.assertEqual(False, repo.get_physical_lock_status())
2298
request_class = smart_repo.SmartServerRepositoryGetPhysicalLockStatus
2299
request = request_class(backing)
2300
self.assertEqual(smart_req.SuccessfulSmartServerResponse((b'no',)),
2301
request.execute(b'', ))
2304
class TestSmartServerRepositoryReconcile(tests.TestCaseWithTransport):
2306
def test_reconcile(self):
2307
backing = self.get_transport()
2308
repo = self.make_repository('.')
2309
token = repo.lock_write().repository_token
2310
self.addCleanup(repo.unlock)
2311
request_class = smart_repo.SmartServerRepositoryReconcile
2312
request = request_class(backing)
2313
self.assertEqual(smart_req.SuccessfulSmartServerResponse(
2315
b'garbage_inventories: 0\n'
2316
b'inconsistent_parents: 0\n'),
2317
request.execute(b'', token))
2320
class TestSmartServerIsReadonly(tests.TestCaseWithMemoryTransport):
2322
def test_is_readonly_no(self):
2323
backing = self.get_transport()
2324
request = smart_req.SmartServerIsReadonly(backing)
2325
response = request.execute()
2327
smart_req.SmartServerResponse((b'no',)), response)
2329
def test_is_readonly_yes(self):
2330
backing = self.get_readonly_transport()
2331
request = smart_req.SmartServerIsReadonly(backing)
2332
response = request.execute()
2334
smart_req.SmartServerResponse((b'yes',)), response)
2337
class TestSmartServerRepositorySetMakeWorkingTrees(
2338
tests.TestCaseWithMemoryTransport):
2340
def test_set_false(self):
2341
backing = self.get_transport()
2342
repo = self.make_repository('.', shared=True)
2343
repo.set_make_working_trees(True)
2344
request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
2345
request = request_class(backing)
2346
self.assertEqual(smart_req.SuccessfulSmartServerResponse((b'ok',)),
2347
request.execute(b'', b'False'))
2348
repo = repo.controldir.open_repository()
2349
self.assertFalse(repo.make_working_trees())
2351
def test_set_true(self):
2352
backing = self.get_transport()
2353
repo = self.make_repository('.', shared=True)
2354
repo.set_make_working_trees(False)
2355
request_class = smart_repo.SmartServerRepositorySetMakeWorkingTrees
2356
request = request_class(backing)
2357
self.assertEqual(smart_req.SuccessfulSmartServerResponse((b'ok',)),
2358
request.execute(b'', b'True'))
2359
repo = repo.controldir.open_repository()
2360
self.assertTrue(repo.make_working_trees())
2363
class TestSmartServerRepositoryGetSerializerFormat(
2364
tests.TestCaseWithMemoryTransport):
2366
def test_get_serializer_format(self):
2367
backing = self.get_transport()
2368
repo = self.make_repository('.', format='2a')
2369
request_class = smart_repo.SmartServerRepositoryGetSerializerFormat
2370
request = request_class(backing)
2372
smart_req.SuccessfulSmartServerResponse((b'ok', b'10')),
2373
request.execute(b''))
2376
class TestSmartServerRepositoryWriteGroup(
2377
tests.TestCaseWithMemoryTransport):
2379
def test_start_write_group(self):
2380
backing = self.get_transport()
2381
repo = self.make_repository('.')
2382
lock_token = repo.lock_write().repository_token
2383
self.addCleanup(repo.unlock)
2384
request_class = smart_repo.SmartServerRepositoryStartWriteGroup
2385
request = request_class(backing)
2386
self.assertEqual(smart_req.SuccessfulSmartServerResponse((b'ok', [])),
2387
request.execute(b'', lock_token))
2389
def test_start_write_group_unsuspendable(self):
2390
backing = self.get_transport()
2391
repo = self.make_repository('.', format='knit')
2392
lock_token = repo.lock_write().repository_token
2393
self.addCleanup(repo.unlock)
2394
request_class = smart_repo.SmartServerRepositoryStartWriteGroup
2395
request = request_class(backing)
2397
smart_req.FailedSmartServerResponse((b'UnsuspendableWriteGroup',)),
2398
request.execute(b'', lock_token))
2400
def test_commit_write_group(self):
2401
backing = self.get_transport()
2402
repo = self.make_repository('.')
2403
lock_token = repo.lock_write().repository_token
2404
self.addCleanup(repo.unlock)
2405
repo.start_write_group()
2406
tokens = repo.suspend_write_group()
2407
request_class = smart_repo.SmartServerRepositoryCommitWriteGroup
2408
request = request_class(backing)
2409
self.assertEqual(smart_req.SuccessfulSmartServerResponse((b'ok',)),
2410
request.execute(b'', lock_token, tokens))
2412
def test_abort_write_group(self):
2413
backing = self.get_transport()
2414
repo = self.make_repository('.')
2415
lock_token = repo.lock_write().repository_token
2416
repo.start_write_group()
2417
tokens = repo.suspend_write_group()
2418
self.addCleanup(repo.unlock)
2419
request_class = smart_repo.SmartServerRepositoryAbortWriteGroup
2420
request = request_class(backing)
2421
self.assertEqual(smart_req.SuccessfulSmartServerResponse((b'ok',)),
2422
request.execute(b'', lock_token, tokens))
2424
def test_check_write_group(self):
2425
backing = self.get_transport()
2426
repo = self.make_repository('.')
2427
lock_token = repo.lock_write().repository_token
2428
repo.start_write_group()
2429
tokens = repo.suspend_write_group()
2430
self.addCleanup(repo.unlock)
2431
request_class = smart_repo.SmartServerRepositoryCheckWriteGroup
2432
request = request_class(backing)
2433
self.assertEqual(smart_req.SuccessfulSmartServerResponse((b'ok',)),
2434
request.execute(b'', lock_token, tokens))
2436
def test_check_write_group_invalid(self):
2437
backing = self.get_transport()
2438
repo = self.make_repository('.')
2439
lock_token = repo.lock_write().repository_token
2440
self.addCleanup(repo.unlock)
2441
request_class = smart_repo.SmartServerRepositoryCheckWriteGroup
2442
request = request_class(backing)
2443
self.assertEqual(smart_req.FailedSmartServerResponse(
2444
(b'UnresumableWriteGroup', [b'random'],
2445
b'Malformed write group token')),
2446
request.execute(b'', lock_token, [b"random"]))
2449
class TestSmartServerPackRepositoryAutopack(tests.TestCaseWithTransport):
2451
def make_repo_needing_autopacking(self, path='.'):
2452
# Make a repo in need of autopacking.
2453
tree = self.make_branch_and_tree('.', format='pack-0.92')
2454
repo = tree.branch.repository
2455
# monkey-patch the pack collection to disable autopacking
2456
repo._pack_collection._max_pack_count = lambda count: count
2458
tree.commit('commit %s' % x)
2459
self.assertEqual(10, len(repo._pack_collection.names()))
2460
del repo._pack_collection._max_pack_count
2463
def test_autopack_needed(self):
2464
repo = self.make_repo_needing_autopacking()
2466
self.addCleanup(repo.unlock)
2467
backing = self.get_transport()
2468
request = smart_packrepo.SmartServerPackRepositoryAutopack(
2470
response = request.execute(b'')
2471
self.assertEqual(smart_req.SmartServerResponse((b'ok',)), response)
2472
repo._pack_collection.reload_pack_names()
2473
self.assertEqual(1, len(repo._pack_collection.names()))
2475
def test_autopack_not_needed(self):
2476
tree = self.make_branch_and_tree('.', format='pack-0.92')
2477
repo = tree.branch.repository
2479
self.addCleanup(repo.unlock)
2481
tree.commit('commit %s' % x)
2482
backing = self.get_transport()
2483
request = smart_packrepo.SmartServerPackRepositoryAutopack(
2485
response = request.execute(b'')
2486
self.assertEqual(smart_req.SmartServerResponse((b'ok',)), response)
2487
repo._pack_collection.reload_pack_names()
2488
self.assertEqual(9, len(repo._pack_collection.names()))
2490
def test_autopack_on_nonpack_format(self):
2491
"""A request to autopack a non-pack repo is a no-op."""
2492
repo = self.make_repository('.', format='knit')
2493
backing = self.get_transport()
2494
request = smart_packrepo.SmartServerPackRepositoryAutopack(
2496
response = request.execute(b'')
2497
self.assertEqual(smart_req.SmartServerResponse((b'ok',)), response)
2500
class TestSmartServerVfsGet(tests.TestCaseWithMemoryTransport):
2502
def test_unicode_path(self):
2503
"""VFS requests expect unicode paths to be escaped."""
2504
filename = u'foo\N{INTERROBANG}'
2505
filename_escaped = urlutils.escape(filename)
2506
backing = self.get_transport()
2507
request = vfs.GetRequest(backing)
2508
backing.put_bytes_non_atomic(filename_escaped, b'contents')
2509
self.assertEqual(smart_req.SmartServerResponse((b'ok', ), b'contents'),
2510
request.execute(filename_escaped.encode('ascii')))
2513
class TestHandlers(tests.TestCase):
2514
"""Tests for the request.request_handlers object."""
2516
def test_all_registrations_exist(self):
2517
"""All registered request_handlers can be found."""
2518
# If there's a typo in a register_lazy call, this loop will fail with
2519
# an AttributeError.
2520
for key in smart_req.request_handlers.keys():
2522
item = smart_req.request_handlers.get(key)
2523
except AttributeError as e:
2524
raise AttributeError('failed to get %s: %s' % (key, e))
2526
def assertHandlerEqual(self, verb, handler):
2527
self.assertEqual(smart_req.request_handlers.get(verb), handler)
2529
def test_registered_methods(self):
2530
"""Test that known methods are registered to the correct object."""
2531
self.assertHandlerEqual(b'Branch.break_lock',
2532
smart_branch.SmartServerBranchBreakLock)
2533
self.assertHandlerEqual(b'Branch.get_config_file',
2534
smart_branch.SmartServerBranchGetConfigFile)
2535
self.assertHandlerEqual(b'Branch.put_config_file',
2536
smart_branch.SmartServerBranchPutConfigFile)
2537
self.assertHandlerEqual(b'Branch.get_parent',
2538
smart_branch.SmartServerBranchGetParent)
2539
self.assertHandlerEqual(b'Branch.get_physical_lock_status',
2540
smart_branch.SmartServerBranchRequestGetPhysicalLockStatus)
2541
self.assertHandlerEqual(b'Branch.get_tags_bytes',
2542
smart_branch.SmartServerBranchGetTagsBytes)
2543
self.assertHandlerEqual(b'Branch.lock_write',
2544
smart_branch.SmartServerBranchRequestLockWrite)
2545
self.assertHandlerEqual(b'Branch.last_revision_info',
2546
smart_branch.SmartServerBranchRequestLastRevisionInfo)
2547
self.assertHandlerEqual(b'Branch.revision_history',
2548
smart_branch.SmartServerRequestRevisionHistory)
2549
self.assertHandlerEqual(b'Branch.revision_id_to_revno',
2550
smart_branch.SmartServerBranchRequestRevisionIdToRevno)
2551
self.assertHandlerEqual(b'Branch.set_config_option',
2552
smart_branch.SmartServerBranchRequestSetConfigOption)
2553
self.assertHandlerEqual(b'Branch.set_last_revision',
2554
smart_branch.SmartServerBranchRequestSetLastRevision)
2555
self.assertHandlerEqual(b'Branch.set_last_revision_info',
2556
smart_branch.SmartServerBranchRequestSetLastRevisionInfo)
2557
self.assertHandlerEqual(b'Branch.set_last_revision_ex',
2558
smart_branch.SmartServerBranchRequestSetLastRevisionEx)
2559
self.assertHandlerEqual(b'Branch.set_parent_location',
2560
smart_branch.SmartServerBranchRequestSetParentLocation)
2561
self.assertHandlerEqual(b'Branch.unlock',
2562
smart_branch.SmartServerBranchRequestUnlock)
2563
self.assertHandlerEqual(b'BzrDir.destroy_branch',
2564
smart_dir.SmartServerBzrDirRequestDestroyBranch)
2565
self.assertHandlerEqual(b'BzrDir.find_repository',
2566
smart_dir.SmartServerRequestFindRepositoryV1)
2567
self.assertHandlerEqual(b'BzrDir.find_repositoryV2',
2568
smart_dir.SmartServerRequestFindRepositoryV2)
2569
self.assertHandlerEqual(b'BzrDirFormat.initialize',
2570
smart_dir.SmartServerRequestInitializeBzrDir)
2571
self.assertHandlerEqual(b'BzrDirFormat.initialize_ex_1.16',
2572
smart_dir.SmartServerRequestBzrDirInitializeEx)
2573
self.assertHandlerEqual(b'BzrDir.checkout_metadir',
2574
smart_dir.SmartServerBzrDirRequestCheckoutMetaDir)
2575
self.assertHandlerEqual(b'BzrDir.cloning_metadir',
2576
smart_dir.SmartServerBzrDirRequestCloningMetaDir)
2577
self.assertHandlerEqual(b'BzrDir.get_branches',
2578
smart_dir.SmartServerBzrDirRequestGetBranches)
2579
self.assertHandlerEqual(b'BzrDir.get_config_file',
2580
smart_dir.SmartServerBzrDirRequestConfigFile)
2581
self.assertHandlerEqual(b'BzrDir.open_branch',
2582
smart_dir.SmartServerRequestOpenBranch)
2583
self.assertHandlerEqual(b'BzrDir.open_branchV2',
2584
smart_dir.SmartServerRequestOpenBranchV2)
2585
self.assertHandlerEqual(b'BzrDir.open_branchV3',
2586
smart_dir.SmartServerRequestOpenBranchV3)
2587
self.assertHandlerEqual(b'PackRepository.autopack',
2588
smart_packrepo.SmartServerPackRepositoryAutopack)
2589
self.assertHandlerEqual(b'Repository.add_signature_text',
2590
smart_repo.SmartServerRepositoryAddSignatureText)
2591
self.assertHandlerEqual(b'Repository.all_revision_ids',
2592
smart_repo.SmartServerRepositoryAllRevisionIds)
2593
self.assertHandlerEqual(b'Repository.break_lock',
2594
smart_repo.SmartServerRepositoryBreakLock)
2595
self.assertHandlerEqual(b'Repository.gather_stats',
2596
smart_repo.SmartServerRepositoryGatherStats)
2597
self.assertHandlerEqual(b'Repository.get_parent_map',
2598
smart_repo.SmartServerRepositoryGetParentMap)
2599
self.assertHandlerEqual(b'Repository.get_physical_lock_status',
2600
smart_repo.SmartServerRepositoryGetPhysicalLockStatus)
2601
self.assertHandlerEqual(b'Repository.get_rev_id_for_revno',
2602
smart_repo.SmartServerRepositoryGetRevIdForRevno)
2603
self.assertHandlerEqual(b'Repository.get_revision_graph',
2604
smart_repo.SmartServerRepositoryGetRevisionGraph)
2605
self.assertHandlerEqual(b'Repository.get_revision_signature_text',
2606
smart_repo.SmartServerRepositoryGetRevisionSignatureText)
2607
self.assertHandlerEqual(b'Repository.get_stream',
2608
smart_repo.SmartServerRepositoryGetStream)
2609
self.assertHandlerEqual(b'Repository.get_stream_1.19',
2610
smart_repo.SmartServerRepositoryGetStream_1_19)
2611
self.assertHandlerEqual(b'Repository.iter_revisions',
2612
smart_repo.SmartServerRepositoryIterRevisions)
2613
self.assertHandlerEqual(b'Repository.has_revision',
2614
smart_repo.SmartServerRequestHasRevision)
2615
self.assertHandlerEqual(b'Repository.insert_stream',
2616
smart_repo.SmartServerRepositoryInsertStream)
2617
self.assertHandlerEqual(b'Repository.insert_stream_locked',
2618
smart_repo.SmartServerRepositoryInsertStreamLocked)
2619
self.assertHandlerEqual(b'Repository.is_shared',
2620
smart_repo.SmartServerRepositoryIsShared)
2621
self.assertHandlerEqual(b'Repository.iter_files_bytes',
2622
smart_repo.SmartServerRepositoryIterFilesBytes)
2623
self.assertHandlerEqual(b'Repository.lock_write',
2624
smart_repo.SmartServerRepositoryLockWrite)
2625
self.assertHandlerEqual(b'Repository.make_working_trees',
2626
smart_repo.SmartServerRepositoryMakeWorkingTrees)
2627
self.assertHandlerEqual(b'Repository.pack',
2628
smart_repo.SmartServerRepositoryPack)
2629
self.assertHandlerEqual(b'Repository.reconcile',
2630
smart_repo.SmartServerRepositoryReconcile)
2631
self.assertHandlerEqual(b'Repository.tarball',
2632
smart_repo.SmartServerRepositoryTarball)
2633
self.assertHandlerEqual(b'Repository.unlock',
2634
smart_repo.SmartServerRepositoryUnlock)
2635
self.assertHandlerEqual(b'Repository.start_write_group',
2636
smart_repo.SmartServerRepositoryStartWriteGroup)
2637
self.assertHandlerEqual(b'Repository.check_write_group',
2638
smart_repo.SmartServerRepositoryCheckWriteGroup)
2639
self.assertHandlerEqual(b'Repository.commit_write_group',
2640
smart_repo.SmartServerRepositoryCommitWriteGroup)
2641
self.assertHandlerEqual(b'Repository.abort_write_group',
2642
smart_repo.SmartServerRepositoryAbortWriteGroup)
2643
self.assertHandlerEqual(b'VersionedFileRepository.get_serializer_format',
2644
smart_repo.SmartServerRepositoryGetSerializerFormat)
2645
self.assertHandlerEqual(b'VersionedFileRepository.get_inventories',
2646
smart_repo.SmartServerRepositoryGetInventories)
2647
self.assertHandlerEqual(b'Transport.is_readonly',
2648
smart_req.SmartServerIsReadonly)
2651
class SmartTCPServerHookTests(tests.TestCaseWithMemoryTransport):
2652
"""Tests for SmartTCPServer hooks."""
2655
super(SmartTCPServerHookTests, self).setUp()
2656
self.server = server.SmartTCPServer(self.get_transport())
2658
def test_run_server_started_hooks(self):
2659
"""Test the server started hooks get fired properly."""
2661
server.SmartTCPServer.hooks.install_named_hook('server_started',
2662
lambda backing_urls, url: started_calls.append(
2663
(backing_urls, url)),
2665
started_ex_calls = []
2666
server.SmartTCPServer.hooks.install_named_hook('server_started_ex',
2667
lambda backing_urls, url: started_ex_calls.append(
2668
(backing_urls, url)),
2670
self.server._sockname = ('example.com', 42)
2671
self.server.run_server_started_hooks()
2672
self.assertEqual(started_calls,
2673
[([self.get_transport().base], 'bzr://example.com:42/')])
2674
self.assertEqual(started_ex_calls,
2675
[([self.get_transport().base], self.server)])
2677
def test_run_server_started_hooks_ipv6(self):
2678
"""Test that socknames can contain 4-tuples."""
2679
self.server._sockname = ('::', 42, 0, 0)
2681
server.SmartTCPServer.hooks.install_named_hook('server_started',
2682
lambda backing_urls, url: started_calls.append(
2683
(backing_urls, url)),
2685
self.server.run_server_started_hooks()
2686
self.assertEqual(started_calls,
2687
[([self.get_transport().base], 'bzr://:::42/')])
2689
def test_run_server_stopped_hooks(self):
2690
"""Test the server stopped hooks."""
2691
self.server._sockname = ('example.com', 42)
2693
server.SmartTCPServer.hooks.install_named_hook('server_stopped',
2694
lambda backing_urls, url: stopped_calls.append(
2695
(backing_urls, url)),
2697
self.server.run_server_stopped_hooks()
2698
self.assertEqual(stopped_calls,
2699
[([self.get_transport().base], 'bzr://example.com:42/')])
2702
class TestSmartServerRepositoryPack(tests.TestCaseWithMemoryTransport):
2704
def test_pack(self):
2705
backing = self.get_transport()
2706
request = smart_repo.SmartServerRepositoryPack(backing)
2707
tree = self.make_branch_and_memory_tree('.')
2708
repo_token = tree.branch.repository.lock_write().repository_token
2710
self.assertIs(None, request.execute(b'', repo_token, False))
2713
smart_req.SuccessfulSmartServerResponse((b'ok', ), ),
2714
request.do_body(b''))
2717
class TestSmartServerRepositoryGetInventories(tests.TestCaseWithTransport):
2719
def _get_serialized_inventory_delta(self, repository, base_revid, revid):
2720
base_inv = repository.revision_tree(base_revid).root_inventory
2721
inv = repository.revision_tree(revid).root_inventory
2722
inv_delta = inv._make_delta(base_inv)
2723
serializer = inventory_delta.InventoryDeltaSerializer(True, True)
2724
return b"".join(serializer.delta_to_lines(base_revid, revid, inv_delta))
2726
def test_single(self):
2727
backing = self.get_transport()
2728
request = smart_repo.SmartServerRepositoryGetInventories(backing)
2729
t = self.make_branch_and_tree('.', format='2a')
2730
self.addCleanup(t.lock_write().unlock)
2731
self.build_tree_contents([("file", b"somecontents")])
2732
t.add(["file"], [b"thefileid"])
2733
t.commit(rev_id=b'somerev', message="add file")
2734
self.assertIs(None, request.execute(b'', b'unordered'))
2735
response = request.do_body(b"somerev\n")
2736
self.assertTrue(response.is_successful())
2737
self.assertEqual(response.args, (b"ok", ))
2738
stream = [('inventory-deltas', [
2739
versionedfile.FulltextContentFactory(b'somerev', None, None,
2740
self._get_serialized_inventory_delta(
2741
t.branch.repository, b'null:', b'somerev'))])]
2742
fmt = controldir.format_registry.get('2a')().repository_format
2744
b"".join(response.body_stream),
2745
b"".join(smart_repo._stream_to_byte_stream(stream, fmt)))
2747
def test_empty(self):
2748
backing = self.get_transport()
2749
request = smart_repo.SmartServerRepositoryGetInventories(backing)
2750
t = self.make_branch_and_tree('.', format='2a')
2751
self.addCleanup(t.lock_write().unlock)
2752
self.build_tree_contents([("file", b"somecontents")])
2753
t.add(["file"], [b"thefileid"])
2754
t.commit(rev_id=b'somerev', message="add file")
2755
self.assertIs(None, request.execute(b'', b'unordered'))
2756
response = request.do_body(b"")
2757
self.assertTrue(response.is_successful())
2758
self.assertEqual(response.args, (b"ok", ))
2759
self.assertEqual(b"".join(response.body_stream),
2760
b"Bazaar pack format 1 (introduced in 0.18)\nB54\n\nBazaar repository format 2a (needs bzr 1.16 or later)\nE")
2763
class TestSmartServerRepositoryGetStreamForMissingKeys(GetStreamTestBase):
2765
def test_missing(self):
2766
"""The search argument may be a 'ancestry-of' some heads'."""
2767
backing = self.get_transport()
2768
request = smart_repo.SmartServerRepositoryGetStreamForMissingKeys(
2770
repo, r1, r2 = self.make_two_commit_repo()
2771
request.execute(b'', repo._format.network_name())
2772
lines = b'inventories\t' + r1
2773
response = request.do_body(lines)
2774
self.assertEqual((b'ok',), response.args)
2775
stream_bytes = b''.join(response.body_stream)
2776
self.assertStartsWith(stream_bytes, b'Bazaar pack format 1')
2778
def test_unknown_format(self):
2779
"""The format may not be known by the remote server."""
2780
backing = self.get_transport()
2781
request = smart_repo.SmartServerRepositoryGetStreamForMissingKeys(
2783
repo, r1, r2 = self.make_two_commit_repo()
2784
request.execute(b'', b'yada yada yada')
2785
expected = smart_req.FailedSmartServerResponse(
2786
(b'UnknownFormat', b'repository', b'yada yada yada'))
2789
class TestSmartServerRepositoryRevisionArchive(tests.TestCaseWithTransport):
2791
backing = self.get_transport()
2792
request = smart_repo.SmartServerRepositoryRevisionArchive(backing)
2793
t = self.make_branch_and_tree('.')
2794
self.addCleanup(t.lock_write().unlock)
2795
self.build_tree_contents([("file", b"somecontents")])
2796
t.add(["file"], [b"thefileid"])
2797
t.commit(rev_id=b'somerev', message="add file")
2798
response = request.execute(b'', b"somerev", b"tar", b"foo.tar", b"foo")
2799
self.assertTrue(response.is_successful())
2800
self.assertEqual(response.args, (b"ok", ))
2801
b = BytesIO(b"".join(response.body_stream))
2802
with tarfile.open(mode='r', fileobj=b) as tf:
2803
self.assertEqual(['foo/file'], tf.getnames())
2806
class TestSmartServerRepositoryAnnotateFileRevision(tests.TestCaseWithTransport):
2809
backing = self.get_transport()
2810
request = smart_repo.SmartServerRepositoryAnnotateFileRevision(backing)
2811
t = self.make_branch_and_tree('.')
2812
self.addCleanup(t.lock_write().unlock)
2813
self.build_tree_contents([("file", b"somecontents\nmorecontents\n")])
2814
t.add(["file"], [b"thefileid"])
2815
t.commit(rev_id=b'somerev', message="add file")
2816
response = request.execute(b'', b"somerev", b"file")
2817
self.assertTrue(response.is_successful())
2818
self.assertEqual(response.args, (b"ok", ))
2820
[[b'somerev', b'somecontents\n'], [b'somerev', b'morecontents\n']],
2821
bencode.bdecode(response.body))
2824
class TestSmartServerBranchRequestGetAllReferenceInfo(TestLockedBranch):
2826
def test_get_some(self):
2827
backing = self.get_transport()
2828
request = smart_branch.SmartServerBranchRequestGetAllReferenceInfo(backing)
2829
branch = self.make_branch('.')
2830
branch.set_reference_info('some/path', 'http://www.example.com/')
2831
response = request.execute(b'')
2832
self.assertTrue(response.is_successful())
2833
self.assertEqual(response.args, (b"ok", ))
2835
[[b'some/path', b'http://www.example.com/', b'']],
2836
bencode.bdecode(response.body))
added
removed
breezy/tests/test_smart.py
