1
# Copyright (C) 2006, 2007 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Tests for the Repository facility that are not interface tests.
19
For interface tests see tests/repository_implementations/*.py.
21
For concrete class tests see this file, and for storage formats tests
26
from stat import S_ISDIR
27
from StringIO import StringIO
30
from bzrlib.errors import (NotBranchError,
33
UnsupportedFormatError,
35
from bzrlib import graph
36
from bzrlib.index import GraphIndex, InMemoryGraphIndex
37
from bzrlib.repository import RepositoryFormat
38
from bzrlib.smart import server
39
from bzrlib.tests import (
41
TestCaseWithTransport,
44
from bzrlib.transport import get_transport
45
from bzrlib.transport.memory import MemoryServer
46
from bzrlib.util import bencode
53
revision as _mod_revision,
58
from bzrlib.repofmt import knitrepo, weaverepo, pack_repo
61
class TestDefaultFormat(TestCase):
63
def test_get_set_default_format(self):
64
old_default = bzrdir.format_registry.get('default')
65
private_default = old_default().repository_format.__class__
66
old_format = repository.RepositoryFormat.get_default_format()
67
self.assertTrue(isinstance(old_format, private_default))
68
def make_sample_bzrdir():
69
my_bzrdir = bzrdir.BzrDirMetaFormat1()
70
my_bzrdir.repository_format = SampleRepositoryFormat()
72
bzrdir.format_registry.remove('default')
73
bzrdir.format_registry.register('sample', make_sample_bzrdir, '')
74
bzrdir.format_registry.set_default('sample')
75
# creating a repository should now create an instrumented dir.
77
# the default branch format is used by the meta dir format
78
# which is not the default bzrdir format at this point
79
dir = bzrdir.BzrDirMetaFormat1().initialize('memory:///')
80
result = dir.create_repository()
81
self.assertEqual(result, 'A bzr repository dir')
83
bzrdir.format_registry.remove('default')
84
bzrdir.format_registry.remove('sample')
85
bzrdir.format_registry.register('default', old_default, '')
86
self.assertIsInstance(repository.RepositoryFormat.get_default_format(),
90
class SampleRepositoryFormat(repository.RepositoryFormat):
93
this format is initializable, unsupported to aid in testing the
94
open and open(unsupported=True) routines.
97
def get_format_string(self):
98
"""See RepositoryFormat.get_format_string()."""
99
return "Sample .bzr repository format."
101
def initialize(self, a_bzrdir, shared=False):
102
"""Initialize a repository in a BzrDir"""
103
t = a_bzrdir.get_repository_transport(self)
104
t.put_bytes('format', self.get_format_string())
105
return 'A bzr repository dir'
107
def is_supported(self):
110
def open(self, a_bzrdir, _found=False):
111
return "opened repository."
114
class TestRepositoryFormat(TestCaseWithTransport):
115
"""Tests for the Repository format detection used by the bzr meta dir facility.BzrBranchFormat facility."""
117
def test_find_format(self):
118
# is the right format object found for a repository?
119
# create a branch with a few known format objects.
120
# this is not quite the same as
121
self.build_tree(["foo/", "bar/"])
122
def check_format(format, url):
123
dir = format._matchingbzrdir.initialize(url)
124
format.initialize(dir)
125
t = get_transport(url)
126
found_format = repository.RepositoryFormat.find_format(dir)
127
self.failUnless(isinstance(found_format, format.__class__))
128
check_format(weaverepo.RepositoryFormat7(), "bar")
130
def test_find_format_no_repository(self):
131
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
132
self.assertRaises(errors.NoRepositoryPresent,
133
repository.RepositoryFormat.find_format,
136
def test_find_format_unknown_format(self):
137
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
138
SampleRepositoryFormat().initialize(dir)
139
self.assertRaises(UnknownFormatError,
140
repository.RepositoryFormat.find_format,
143
def test_register_unregister_format(self):
144
format = SampleRepositoryFormat()
146
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
148
format.initialize(dir)
149
# register a format for it.
150
repository.RepositoryFormat.register_format(format)
151
# which repository.Open will refuse (not supported)
152
self.assertRaises(UnsupportedFormatError, repository.Repository.open, self.get_url())
153
# but open(unsupported) will work
154
self.assertEqual(format.open(dir), "opened repository.")
155
# unregister the format
156
repository.RepositoryFormat.unregister_format(format)
159
class TestFormat6(TestCaseWithTransport):
161
def test_no_ancestry_weave(self):
162
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
163
repo = weaverepo.RepositoryFormat6().initialize(control)
164
# We no longer need to create the ancestry.weave file
165
# since it is *never* used.
166
self.assertRaises(NoSuchFile,
167
control.transport.get,
170
def test_exposed_versioned_files_are_marked_dirty(self):
171
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
172
repo = weaverepo.RepositoryFormat6().initialize(control)
174
inv = repo.get_inventory_weave()
176
self.assertRaises(errors.OutSideTransaction,
177
inv.add_lines, 'foo', [], [])
179
def test_supports_external_lookups(self):
180
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
181
repo = weaverepo.RepositoryFormat6().initialize(control)
182
self.assertFalse(repo._format.supports_external_lookups)
185
class TestFormat7(TestCaseWithTransport):
187
def test_disk_layout(self):
188
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
189
repo = weaverepo.RepositoryFormat7().initialize(control)
190
# in case of side effects of locking.
194
# format 'Bazaar-NG Repository format 7'
196
# inventory.weave == empty_weave
197
# empty revision-store directory
198
# empty weaves directory
199
t = control.get_repository_transport(None)
200
self.assertEqualDiff('Bazaar-NG Repository format 7',
201
t.get('format').read())
202
self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
203
self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
204
self.assertEqualDiff('# bzr weave file v5\n'
207
t.get('inventory.weave').read())
209
def test_shared_disk_layout(self):
210
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
211
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
213
# format 'Bazaar-NG Repository format 7'
214
# inventory.weave == empty_weave
215
# empty revision-store directory
216
# empty weaves directory
217
# a 'shared-storage' marker file.
218
# lock is not present when unlocked
219
t = control.get_repository_transport(None)
220
self.assertEqualDiff('Bazaar-NG Repository format 7',
221
t.get('format').read())
222
self.assertEqualDiff('', t.get('shared-storage').read())
223
self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
224
self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
225
self.assertEqualDiff('# bzr weave file v5\n'
228
t.get('inventory.weave').read())
229
self.assertFalse(t.has('branch-lock'))
231
def test_creates_lockdir(self):
232
"""Make sure it appears to be controlled by a LockDir existence"""
233
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
234
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
235
t = control.get_repository_transport(None)
236
# TODO: Should check there is a 'lock' toplevel directory,
237
# regardless of contents
238
self.assertFalse(t.has('lock/held/info'))
241
self.assertTrue(t.has('lock/held/info'))
243
# unlock so we don't get a warning about failing to do so
246
def test_uses_lockdir(self):
247
"""repo format 7 actually locks on lockdir"""
248
base_url = self.get_url()
249
control = bzrdir.BzrDirMetaFormat1().initialize(base_url)
250
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
251
t = control.get_repository_transport(None)
255
# make sure the same lock is created by opening it
256
repo = repository.Repository.open(base_url)
258
self.assertTrue(t.has('lock/held/info'))
260
self.assertFalse(t.has('lock/held/info'))
262
def test_shared_no_tree_disk_layout(self):
263
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
264
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
265
repo.set_make_working_trees(False)
267
# format 'Bazaar-NG Repository format 7'
269
# inventory.weave == empty_weave
270
# empty revision-store directory
271
# empty weaves directory
272
# a 'shared-storage' marker file.
273
t = control.get_repository_transport(None)
274
self.assertEqualDiff('Bazaar-NG Repository format 7',
275
t.get('format').read())
276
## self.assertEqualDiff('', t.get('lock').read())
277
self.assertEqualDiff('', t.get('shared-storage').read())
278
self.assertEqualDiff('', t.get('no-working-trees').read())
279
repo.set_make_working_trees(True)
280
self.assertFalse(t.has('no-working-trees'))
281
self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
282
self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
283
self.assertEqualDiff('# bzr weave file v5\n'
286
t.get('inventory.weave').read())
288
def test_exposed_versioned_files_are_marked_dirty(self):
289
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
290
repo = weaverepo.RepositoryFormat7().initialize(control)
292
inv = repo.get_inventory_weave()
294
self.assertRaises(errors.OutSideTransaction,
295
inv.add_lines, 'foo', [], [])
297
def test_supports_external_lookups(self):
298
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
299
repo = weaverepo.RepositoryFormat7().initialize(control)
300
self.assertFalse(repo._format.supports_external_lookups)
303
class TestFormatKnit1(TestCaseWithTransport):
305
def test_disk_layout(self):
306
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
307
repo = knitrepo.RepositoryFormatKnit1().initialize(control)
308
# in case of side effects of locking.
312
# format 'Bazaar-NG Knit Repository Format 1'
313
# lock: is a directory
314
# inventory.weave == empty_weave
315
# empty revision-store directory
316
# empty weaves directory
317
t = control.get_repository_transport(None)
318
self.assertEqualDiff('Bazaar-NG Knit Repository Format 1',
319
t.get('format').read())
320
# XXX: no locks left when unlocked at the moment
321
# self.assertEqualDiff('', t.get('lock').read())
322
self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
325
def assertHasKnit(self, t, knit_name):
326
"""Assert that knit_name exists on t."""
327
self.assertEqualDiff('# bzr knit index 8\n',
328
t.get(knit_name + '.kndx').read())
330
self.assertTrue(t.has(knit_name + '.knit'))
332
def check_knits(self, t):
333
"""check knit content for a repository."""
334
self.assertHasKnit(t, 'inventory')
335
self.assertHasKnit(t, 'revisions')
336
self.assertHasKnit(t, 'signatures')
338
def test_shared_disk_layout(self):
339
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
340
repo = knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
342
# format 'Bazaar-NG Knit Repository Format 1'
343
# lock: is a directory
344
# inventory.weave == empty_weave
345
# empty revision-store directory
346
# empty weaves directory
347
# a 'shared-storage' marker file.
348
t = control.get_repository_transport(None)
349
self.assertEqualDiff('Bazaar-NG Knit Repository Format 1',
350
t.get('format').read())
351
# XXX: no locks left when unlocked at the moment
352
# self.assertEqualDiff('', t.get('lock').read())
353
self.assertEqualDiff('', t.get('shared-storage').read())
354
self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
357
def test_shared_no_tree_disk_layout(self):
358
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
359
repo = knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
360
repo.set_make_working_trees(False)
362
# format 'Bazaar-NG Knit Repository Format 1'
364
# inventory.weave == empty_weave
365
# empty revision-store directory
366
# empty weaves directory
367
# a 'shared-storage' marker file.
368
t = control.get_repository_transport(None)
369
self.assertEqualDiff('Bazaar-NG Knit Repository Format 1',
370
t.get('format').read())
371
# XXX: no locks left when unlocked at the moment
372
# self.assertEqualDiff('', t.get('lock').read())
373
self.assertEqualDiff('', t.get('shared-storage').read())
374
self.assertEqualDiff('', t.get('no-working-trees').read())
375
repo.set_make_working_trees(True)
376
self.assertFalse(t.has('no-working-trees'))
377
self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
380
def test_exposed_versioned_files_are_marked_dirty(self):
381
format = bzrdir.BzrDirMetaFormat1()
382
format.repository_format = knitrepo.RepositoryFormatKnit1()
383
repo = self.make_repository('.', format=format)
385
inv = repo.get_inventory_weave()
387
self.assertRaises(errors.OutSideTransaction,
388
inv.add_lines, 'foo', [], [])
390
def test_deserialise_sets_root_revision(self):
391
"""We must have a inventory.root.revision
393
Old versions of the XML5 serializer did not set the revision_id for
394
the whole inventory. So we grab the one from the expected text. Which
395
is valid when the api is not being abused.
397
repo = self.make_repository('.',
398
format=bzrdir.format_registry.get('knit')())
399
inv_xml = '<inventory format="5">\n</inventory>\n'
400
inv = repo.deserialise_inventory('test-rev-id', inv_xml)
401
self.assertEqual('test-rev-id', inv.root.revision)
403
def test_deserialise_uses_global_revision_id(self):
404
"""If it is set, then we re-use the global revision id"""
405
repo = self.make_repository('.',
406
format=bzrdir.format_registry.get('knit')())
407
inv_xml = ('<inventory format="5" revision_id="other-rev-id">\n'
409
# Arguably, the deserialise_inventory should detect a mismatch, and
410
# raise an error, rather than silently using one revision_id over the
412
self.assertRaises(AssertionError, repo.deserialise_inventory,
413
'test-rev-id', inv_xml)
414
inv = repo.deserialise_inventory('other-rev-id', inv_xml)
415
self.assertEqual('other-rev-id', inv.root.revision)
417
def test_supports_external_lookups(self):
418
repo = self.make_repository('.',
419
format=bzrdir.format_registry.get('knit')())
420
self.assertFalse(repo._format.supports_external_lookups)
423
class KnitRepositoryStreamTests(test_knit.KnitTests):
424
"""Tests for knitrepo._get_stream_as_bytes."""
426
def test_get_stream_as_bytes(self):
428
k1 = self.make_test_knit()
429
k1.add_lines('text-a', [], test_knit.split_lines(test_knit.TEXT_1))
431
# Serialise it, check the output.
432
bytes = knitrepo._get_stream_as_bytes(k1, ['text-a'])
433
data = bencode.bdecode(bytes)
434
format, record = data
435
self.assertEqual('knit-plain', format)
436
self.assertEqual(['text-a', ['fulltext'], []], record[:3])
437
self.assertRecordContentEqual(k1, 'text-a', record[3])
439
def test_get_stream_as_bytes_all(self):
440
"""Get a serialised data stream for all the records in a knit.
442
Much like test_get_stream_all, except for get_stream_as_bytes.
444
k1 = self.make_test_knit()
445
# Insert the same data as BasicKnitTests.test_knit_join, as they seem
446
# to cover a range of cases (no parents, one parent, multiple parents).
448
('text-a', [], test_knit.TEXT_1),
449
('text-b', ['text-a'], test_knit.TEXT_1),
450
('text-c', [], test_knit.TEXT_1),
451
('text-d', ['text-c'], test_knit.TEXT_1),
452
('text-m', ['text-b', 'text-d'], test_knit.TEXT_1),
454
# This test is actually a bit strict as the order in which they're
455
# returned is not defined. This matches the current (deterministic)
457
expected_data_list = [
458
# version, options, parents
459
('text-a', ['fulltext'], []),
460
('text-b', ['line-delta'], ['text-a']),
461
('text-m', ['line-delta'], ['text-b', 'text-d']),
462
('text-c', ['fulltext'], []),
463
('text-d', ['line-delta'], ['text-c']),
465
for version_id, parents, lines in test_data:
466
k1.add_lines(version_id, parents, test_knit.split_lines(lines))
468
bytes = knitrepo._get_stream_as_bytes(
469
k1, ['text-a', 'text-b', 'text-m', 'text-c', 'text-d', ])
471
data = bencode.bdecode(bytes)
473
self.assertEqual('knit-plain', format)
475
for expected, actual in zip(expected_data_list, data):
476
expected_version = expected[0]
477
expected_options = expected[1]
478
expected_parents = expected[2]
479
version, options, parents, bytes = actual
480
self.assertEqual(expected_version, version)
481
self.assertEqual(expected_options, options)
482
self.assertEqual(expected_parents, parents)
483
self.assertRecordContentEqual(k1, version, bytes)
486
class DummyRepository(object):
487
"""A dummy repository for testing."""
491
def supports_rich_root(self):
495
class InterDummy(repository.InterRepository):
496
"""An inter-repository optimised code path for DummyRepository.
498
This is for use during testing where we use DummyRepository as repositories
499
so that none of the default regsitered inter-repository classes will
504
def is_compatible(repo_source, repo_target):
505
"""InterDummy is compatible with DummyRepository."""
506
return (isinstance(repo_source, DummyRepository) and
507
isinstance(repo_target, DummyRepository))
510
class TestInterRepository(TestCaseWithTransport):
512
def test_get_default_inter_repository(self):
513
# test that the InterRepository.get(repo_a, repo_b) probes
514
# for a inter_repo class where is_compatible(repo_a, repo_b) returns
515
# true and returns a default inter_repo otherwise.
516
# This also tests that the default registered optimised interrepository
517
# classes do not barf inappropriately when a surprising repository type
519
dummy_a = DummyRepository()
520
dummy_b = DummyRepository()
521
self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
523
def assertGetsDefaultInterRepository(self, repo_a, repo_b):
524
"""Asserts that InterRepository.get(repo_a, repo_b) -> the default.
526
The effective default is now InterSameDataRepository because there is
527
no actual sane default in the presence of incompatible data models.
529
inter_repo = repository.InterRepository.get(repo_a, repo_b)
530
self.assertEqual(repository.InterSameDataRepository,
531
inter_repo.__class__)
532
self.assertEqual(repo_a, inter_repo.source)
533
self.assertEqual(repo_b, inter_repo.target)
535
def test_register_inter_repository_class(self):
536
# test that a optimised code path provider - a
537
# InterRepository subclass can be registered and unregistered
538
# and that it is correctly selected when given a repository
539
# pair that it returns true on for the is_compatible static method
541
dummy_a = DummyRepository()
542
dummy_b = DummyRepository()
543
repo = self.make_repository('.')
544
# hack dummies to look like repo somewhat.
545
dummy_a._serializer = repo._serializer
546
dummy_b._serializer = repo._serializer
547
repository.InterRepository.register_optimiser(InterDummy)
549
# we should get the default for something InterDummy returns False
551
self.assertFalse(InterDummy.is_compatible(dummy_a, repo))
552
self.assertGetsDefaultInterRepository(dummy_a, repo)
553
# and we should get an InterDummy for a pair it 'likes'
554
self.assertTrue(InterDummy.is_compatible(dummy_a, dummy_b))
555
inter_repo = repository.InterRepository.get(dummy_a, dummy_b)
556
self.assertEqual(InterDummy, inter_repo.__class__)
557
self.assertEqual(dummy_a, inter_repo.source)
558
self.assertEqual(dummy_b, inter_repo.target)
560
repository.InterRepository.unregister_optimiser(InterDummy)
561
# now we should get the default InterRepository object again.
562
self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
565
class TestInterWeaveRepo(TestCaseWithTransport):
567
def test_is_compatible_and_registered(self):
568
# InterWeaveRepo is compatible when either side
569
# is a format 5/6/7 branch
570
from bzrlib.repofmt import knitrepo, weaverepo
571
formats = [weaverepo.RepositoryFormat5(),
572
weaverepo.RepositoryFormat6(),
573
weaverepo.RepositoryFormat7()]
574
incompatible_formats = [weaverepo.RepositoryFormat4(),
575
knitrepo.RepositoryFormatKnit1(),
577
repo_a = self.make_repository('a')
578
repo_b = self.make_repository('b')
579
is_compatible = repository.InterWeaveRepo.is_compatible
580
for source in incompatible_formats:
581
# force incompatible left then right
582
repo_a._format = source
583
repo_b._format = formats[0]
584
self.assertFalse(is_compatible(repo_a, repo_b))
585
self.assertFalse(is_compatible(repo_b, repo_a))
586
for source in formats:
587
repo_a._format = source
588
for target in formats:
589
repo_b._format = target
590
self.assertTrue(is_compatible(repo_a, repo_b))
591
self.assertEqual(repository.InterWeaveRepo,
592
repository.InterRepository.get(repo_a,
596
class TestInterRemoteToOther(TestCaseWithTransport):
598
def make_remote_repository(self, path, backing_format=None):
599
"""Make a RemoteRepository object backed by a real repository that will
600
be created at the given path."""
601
self.make_repository(path, format=backing_format)
602
smart_server = server.SmartTCPServer_for_testing()
604
remote_transport = get_transport(smart_server.get_url()).clone(path)
605
self.addCleanup(smart_server.tearDown)
606
remote_bzrdir = bzrdir.BzrDir.open_from_transport(remote_transport)
607
remote_repo = remote_bzrdir.open_repository()
610
def test_is_compatible_same_format(self):
611
"""InterRemoteToOther is compatible with a remote repository and a
612
second repository that have the same format."""
613
local_repo = self.make_repository('local')
614
remote_repo = self.make_remote_repository('remote')
615
is_compatible = repository.InterRemoteToOther.is_compatible
617
is_compatible(remote_repo, local_repo),
618
"InterRemoteToOther(%r, %r) is false" % (remote_repo, local_repo))
620
def test_is_incompatible_different_format(self):
621
local_repo = self.make_repository('local', 'dirstate')
622
remote_repo = self.make_remote_repository('a', 'dirstate-with-subtree')
623
is_compatible = repository.InterRemoteToOther.is_compatible
625
is_compatible(remote_repo, local_repo),
626
"InterRemoteToOther(%r, %r) is true" % (local_repo, remote_repo))
628
def test_is_incompatible_different_format_both_remote(self):
629
remote_repo_a = self.make_remote_repository(
630
'a', 'dirstate-with-subtree')
631
remote_repo_b = self.make_remote_repository('b', 'dirstate')
632
is_compatible = repository.InterRemoteToOther.is_compatible
634
is_compatible(remote_repo_a, remote_repo_b),
635
"InterRemoteToOther(%r, %r) is true"
636
% (remote_repo_a, remote_repo_b))
639
class TestRepositoryConverter(TestCaseWithTransport):
641
def test_convert_empty(self):
642
t = get_transport(self.get_url('.'))
643
t.mkdir('repository')
644
repo_dir = bzrdir.BzrDirMetaFormat1().initialize('repository')
645
repo = weaverepo.RepositoryFormat7().initialize(repo_dir)
646
target_format = knitrepo.RepositoryFormatKnit1()
647
converter = repository.CopyConverter(target_format)
648
pb = bzrlib.ui.ui_factory.nested_progress_bar()
650
converter.convert(repo, pb)
653
repo = repo_dir.open_repository()
654
self.assertTrue(isinstance(target_format, repo._format.__class__))
657
class TestMisc(TestCase):
659
def test_unescape_xml(self):
660
"""We get some kind of error when malformed entities are passed"""
661
self.assertRaises(KeyError, repository._unescape_xml, 'foo&bar;')
664
class TestRepositoryFormatKnit3(TestCaseWithTransport):
666
def test_convert(self):
667
"""Ensure the upgrade adds weaves for roots"""
668
format = bzrdir.BzrDirMetaFormat1()
669
format.repository_format = knitrepo.RepositoryFormatKnit1()
670
tree = self.make_branch_and_tree('.', format)
671
tree.commit("Dull commit", rev_id="dull")
672
revision_tree = tree.branch.repository.revision_tree('dull')
673
self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
674
revision_tree.inventory.root.file_id)
675
format = bzrdir.BzrDirMetaFormat1()
676
format.repository_format = knitrepo.RepositoryFormatKnit3()
677
upgrade.Convert('.', format)
678
tree = workingtree.WorkingTree.open('.')
679
revision_tree = tree.branch.repository.revision_tree('dull')
680
revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
681
tree.commit("Another dull commit", rev_id='dull2')
682
revision_tree = tree.branch.repository.revision_tree('dull2')
683
self.assertEqual('dull', revision_tree.inventory.root.revision)
685
def test_exposed_versioned_files_are_marked_dirty(self):
686
format = bzrdir.BzrDirMetaFormat1()
687
format.repository_format = knitrepo.RepositoryFormatKnit3()
688
repo = self.make_repository('.', format=format)
690
inv = repo.get_inventory_weave()
692
self.assertRaises(errors.OutSideTransaction,
693
inv.add_lines, 'foo', [], [])
695
def test_supports_external_lookups(self):
696
format = bzrdir.BzrDirMetaFormat1()
697
format.repository_format = knitrepo.RepositoryFormatKnit3()
698
repo = self.make_repository('.', format=format)
699
self.assertFalse(repo._format.supports_external_lookups)
702
class TestWithBrokenRepo(TestCaseWithTransport):
703
"""These tests seem to be more appropriate as interface tests?"""
705
def make_broken_repository(self):
706
# XXX: This function is borrowed from Aaron's "Reconcile can fix bad
707
# parent references" branch which is due to land in bzr.dev soon. Once
708
# it does, this duplication should be removed.
709
repo = self.make_repository('broken-repo')
713
cleanups.append(repo.unlock)
714
repo.start_write_group()
715
cleanups.append(repo.commit_write_group)
716
# make rev1a: A well-formed revision, containing 'file1'
717
inv = inventory.Inventory(revision_id='rev1a')
718
inv.root.revision = 'rev1a'
719
self.add_file(repo, inv, 'file1', 'rev1a', [])
720
repo.add_inventory('rev1a', inv, [])
721
revision = _mod_revision.Revision('rev1a',
722
committer='jrandom@example.com', timestamp=0,
723
inventory_sha1='', timezone=0, message='foo', parent_ids=[])
724
repo.add_revision('rev1a',revision, inv)
726
# make rev1b, which has no Revision, but has an Inventory, and
728
inv = inventory.Inventory(revision_id='rev1b')
729
inv.root.revision = 'rev1b'
730
self.add_file(repo, inv, 'file1', 'rev1b', [])
731
repo.add_inventory('rev1b', inv, [])
733
# make rev2, with file1 and file2
735
# file1 has 'rev1b' as an ancestor, even though this is not
736
# mentioned by 'rev1a', making it an unreferenced ancestor
737
inv = inventory.Inventory()
738
self.add_file(repo, inv, 'file1', 'rev2', ['rev1a', 'rev1b'])
739
self.add_file(repo, inv, 'file2', 'rev2', [])
740
self.add_revision(repo, 'rev2', inv, ['rev1a'])
742
# make ghost revision rev1c
743
inv = inventory.Inventory()
744
self.add_file(repo, inv, 'file2', 'rev1c', [])
746
# make rev3 with file2
747
# file2 refers to 'rev1c', which is a ghost in this repository, so
748
# file2 cannot have rev1c as its ancestor.
749
inv = inventory.Inventory()
750
self.add_file(repo, inv, 'file2', 'rev3', ['rev1c'])
751
self.add_revision(repo, 'rev3', inv, ['rev1c'])
754
for cleanup in reversed(cleanups):
757
def add_revision(self, repo, revision_id, inv, parent_ids):
758
inv.revision_id = revision_id
759
inv.root.revision = revision_id
760
repo.add_inventory(revision_id, inv, parent_ids)
761
revision = _mod_revision.Revision(revision_id,
762
committer='jrandom@example.com', timestamp=0, inventory_sha1='',
763
timezone=0, message='foo', parent_ids=parent_ids)
764
repo.add_revision(revision_id,revision, inv)
766
def add_file(self, repo, inv, filename, revision, parents):
767
file_id = filename + '-id'
768
entry = inventory.InventoryFile(file_id, filename, 'TREE_ROOT')
769
entry.revision = revision
772
vf = repo.weave_store.get_weave_or_empty(file_id,
773
repo.get_transaction())
774
vf.add_lines(revision, parents, ['line\n'])
776
def test_insert_from_broken_repo(self):
777
"""Inserting a data stream from a broken repository won't silently
778
corrupt the target repository.
780
broken_repo = self.make_broken_repository()
781
empty_repo = self.make_repository('empty-repo')
782
search = graph.SearchResult(set(['rev1a', 'rev2', 'rev3']),
783
set(), 3, ['rev1a', 'rev2', 'rev3'])
784
broken_repo.lock_read()
785
self.addCleanup(broken_repo.unlock)
786
stream = broken_repo.get_data_stream_for_search(search)
787
empty_repo.lock_write()
788
self.addCleanup(empty_repo.unlock)
789
empty_repo.start_write_group()
792
errors.KnitCorrupt, empty_repo.insert_data_stream, stream)
794
empty_repo.abort_write_group()
797
class TestKnitPackNoSubtrees(TestCaseWithTransport):
799
def get_format(self):
800
return bzrdir.format_registry.make_bzrdir('pack-0.92')
802
def test_disk_layout(self):
803
format = self.get_format()
804
repo = self.make_repository('.', format=format)
805
# in case of side effects of locking.
808
t = repo.bzrdir.get_repository_transport(None)
810
# XXX: no locks left when unlocked at the moment
811
# self.assertEqualDiff('', t.get('lock').read())
812
self.check_databases(t)
814
def check_format(self, t):
815
self.assertEqualDiff(
816
"Bazaar pack repository format 1 (needs bzr 0.92)\n",
817
t.get('format').read())
819
def assertHasKndx(self, t, knit_name):
820
"""Assert that knit_name exists on t."""
821
self.assertEqualDiff('# bzr knit index 8\n',
822
t.get(knit_name + '.kndx').read())
824
def assertHasNoKndx(self, t, knit_name):
825
"""Assert that knit_name has no index on t."""
826
self.assertFalse(t.has(knit_name + '.kndx'))
828
def assertHasNoKnit(self, t, knit_name):
829
"""Assert that knit_name exists on t."""
831
self.assertFalse(t.has(knit_name + '.knit'))
833
def check_databases(self, t):
834
"""check knit content for a repository."""
835
# check conversion worked
836
self.assertHasNoKndx(t, 'inventory')
837
self.assertHasNoKnit(t, 'inventory')
838
self.assertHasNoKndx(t, 'revisions')
839
self.assertHasNoKnit(t, 'revisions')
840
self.assertHasNoKndx(t, 'signatures')
841
self.assertHasNoKnit(t, 'signatures')
842
self.assertFalse(t.has('knits'))
843
# revision-indexes file-container directory
845
list(GraphIndex(t, 'pack-names', None).iter_all_entries()))
846
self.assertTrue(S_ISDIR(t.stat('packs').st_mode))
847
self.assertTrue(S_ISDIR(t.stat('upload').st_mode))
848
self.assertTrue(S_ISDIR(t.stat('indices').st_mode))
849
self.assertTrue(S_ISDIR(t.stat('obsolete_packs').st_mode))
851
def test_shared_disk_layout(self):
852
format = self.get_format()
853
repo = self.make_repository('.', shared=True, format=format)
855
t = repo.bzrdir.get_repository_transport(None)
857
# XXX: no locks left when unlocked at the moment
858
# self.assertEqualDiff('', t.get('lock').read())
859
# We should have a 'shared-storage' marker file.
860
self.assertEqualDiff('', t.get('shared-storage').read())
861
self.check_databases(t)
863
def test_shared_no_tree_disk_layout(self):
864
format = self.get_format()
865
repo = self.make_repository('.', shared=True, format=format)
866
repo.set_make_working_trees(False)
868
t = repo.bzrdir.get_repository_transport(None)
870
# XXX: no locks left when unlocked at the moment
871
# self.assertEqualDiff('', t.get('lock').read())
872
# We should have a 'shared-storage' marker file.
873
self.assertEqualDiff('', t.get('shared-storage').read())
874
# We should have a marker for the no-working-trees flag.
875
self.assertEqualDiff('', t.get('no-working-trees').read())
876
# The marker should go when we toggle the setting.
877
repo.set_make_working_trees(True)
878
self.assertFalse(t.has('no-working-trees'))
879
self.check_databases(t)
881
def test_adding_revision_creates_pack_indices(self):
882
format = self.get_format()
883
tree = self.make_branch_and_tree('.', format=format)
884
trans = tree.branch.repository.bzrdir.get_repository_transport(None)
886
list(GraphIndex(trans, 'pack-names', None).iter_all_entries()))
887
tree.commit('foobarbaz')
888
index = GraphIndex(trans, 'pack-names', None)
889
index_nodes = list(index.iter_all_entries())
890
self.assertEqual(1, len(index_nodes))
891
node = index_nodes[0]
893
# the pack sizes should be listed in the index
895
sizes = [int(digits) for digits in pack_value.split(' ')]
896
for size, suffix in zip(sizes, ['.rix', '.iix', '.tix', '.six']):
897
stat = trans.stat('indices/%s%s' % (name, suffix))
898
self.assertEqual(size, stat.st_size)
900
def test_pulling_nothing_leads_to_no_new_names(self):
901
format = self.get_format()
902
tree1 = self.make_branch_and_tree('1', format=format)
903
tree2 = self.make_branch_and_tree('2', format=format)
904
tree1.branch.repository.fetch(tree2.branch.repository)
905
trans = tree1.branch.repository.bzrdir.get_repository_transport(None)
907
list(GraphIndex(trans, 'pack-names', None).iter_all_entries()))
909
def test_commit_across_pack_shape_boundary_autopacks(self):
910
format = self.get_format()
911
tree = self.make_branch_and_tree('.', format=format)
912
trans = tree.branch.repository.bzrdir.get_repository_transport(None)
913
# This test could be a little cheaper by replacing the packs
914
# attribute on the repository to allow a different pack distribution
915
# and max packs policy - so we are checking the policy is honoured
916
# in the test. But for now 11 commits is not a big deal in a single
919
tree.commit('commit %s' % x)
920
# there should be 9 packs:
921
index = GraphIndex(trans, 'pack-names', None)
922
self.assertEqual(9, len(list(index.iter_all_entries())))
923
# insert some files in obsolete_packs which should be removed by pack.
924
trans.put_bytes('obsolete_packs/foo', '123')
925
trans.put_bytes('obsolete_packs/bar', '321')
926
# committing one more should coalesce to 1 of 10.
927
tree.commit('commit triggering pack')
928
index = GraphIndex(trans, 'pack-names', None)
929
self.assertEqual(1, len(list(index.iter_all_entries())))
930
# packing should not damage data
931
tree = tree.bzrdir.open_workingtree()
932
check_result = tree.branch.repository.check(
933
[tree.branch.last_revision()])
934
# We should have 50 (10x5) files in the obsolete_packs directory.
935
obsolete_files = list(trans.list_dir('obsolete_packs'))
936
self.assertFalse('foo' in obsolete_files)
937
self.assertFalse('bar' in obsolete_files)
938
self.assertEqual(50, len(obsolete_files))
939
# XXX: Todo check packs obsoleted correctly - old packs and indices
940
# in the obsolete_packs directory.
941
large_pack_name = list(index.iter_all_entries())[0][1][0]
942
# finally, committing again should not touch the large pack.
943
tree.commit('commit not triggering pack')
944
index = GraphIndex(trans, 'pack-names', None)
945
self.assertEqual(2, len(list(index.iter_all_entries())))
946
pack_names = [node[1][0] for node in index.iter_all_entries()]
947
self.assertTrue(large_pack_name in pack_names)
949
def test_pack_after_two_commits_packs_everything(self):
950
format = self.get_format()
951
tree = self.make_branch_and_tree('.', format=format)
952
trans = tree.branch.repository.bzrdir.get_repository_transport(None)
954
tree.commit('more work')
955
tree.branch.repository.pack()
956
# there should be 1 pack:
957
index = GraphIndex(trans, 'pack-names', None)
958
self.assertEqual(1, len(list(index.iter_all_entries())))
959
self.assertEqual(2, len(tree.branch.repository.all_revision_ids()))
961
def test_pack_layout(self):
962
format = self.get_format()
963
tree = self.make_branch_and_tree('.', format=format)
964
trans = tree.branch.repository.bzrdir.get_repository_transport(None)
965
tree.commit('start', rev_id='1')
966
tree.commit('more work', rev_id='2')
967
tree.branch.repository.pack()
969
self.addCleanup(tree.unlock)
970
pack = tree.branch.repository._pack_collection.get_pack_by_name(
971
tree.branch.repository._pack_collection.names()[0])
972
# revision access tends to be tip->ancestor, so ordering that way on
973
# disk is a good idea.
974
for _1, key, val, refs in pack.revision_index.iter_all_entries():
976
pos_1 = int(val[1:].split()[0])
978
pos_2 = int(val[1:].split()[0])
979
self.assertTrue(pos_2 < pos_1)
981
def test_pack_repositories_support_multiple_write_locks(self):
982
format = self.get_format()
983
self.make_repository('.', shared=True, format=format)
984
r1 = repository.Repository.open('.')
985
r2 = repository.Repository.open('.')
987
self.addCleanup(r1.unlock)
991
def _add_text(self, repo, fileid):
992
"""Add a text to the repository within a write group."""
993
vf =repo.weave_store.get_weave(fileid, repo.get_transaction())
994
vf.add_lines('samplerev+' + fileid, [], [])
996
def test_concurrent_writers_merge_new_packs(self):
997
format = self.get_format()
998
self.make_repository('.', shared=True, format=format)
999
r1 = repository.Repository.open('.')
1000
r2 = repository.Repository.open('.')
1003
# access enough data to load the names list
1004
list(r1.all_revision_ids())
1007
# access enough data to load the names list
1008
list(r2.all_revision_ids())
1009
r1.start_write_group()
1011
r2.start_write_group()
1013
self._add_text(r1, 'fileidr1')
1014
self._add_text(r2, 'fileidr2')
1016
r2.abort_write_group()
1019
r1.abort_write_group()
1021
# both r1 and r2 have open write groups with data in them
1022
# created while the other's write group was open.
1023
# Commit both which requires a merge to the pack-names.
1025
r1.commit_write_group()
1027
r1.abort_write_group()
1028
r2.abort_write_group()
1030
r2.commit_write_group()
1031
# tell r1 to reload from disk
1032
r1._pack_collection.reset()
1033
# Now both repositories should know about both names
1034
r1._pack_collection.ensure_loaded()
1035
r2._pack_collection.ensure_loaded()
1036
self.assertEqual(r1._pack_collection.names(), r2._pack_collection.names())
1037
self.assertEqual(2, len(r1._pack_collection.names()))
1043
def test_concurrent_writer_second_preserves_dropping_a_pack(self):
1044
format = self.get_format()
1045
self.make_repository('.', shared=True, format=format)
1046
r1 = repository.Repository.open('.')
1047
r2 = repository.Repository.open('.')
1048
# add a pack to drop
1051
r1.start_write_group()
1053
self._add_text(r1, 'fileidr1')
1055
r1.abort_write_group()
1058
r1.commit_write_group()
1059
r1._pack_collection.ensure_loaded()
1060
name_to_drop = r1._pack_collection.all_packs()[0].name
1065
# access enough data to load the names list
1066
list(r1.all_revision_ids())
1069
# access enough data to load the names list
1070
list(r2.all_revision_ids())
1071
r1._pack_collection.ensure_loaded()
1073
r2.start_write_group()
1075
# in r1, drop the pack
1076
r1._pack_collection._remove_pack_from_memory(
1077
r1._pack_collection.get_pack_by_name(name_to_drop))
1079
self._add_text(r2, 'fileidr2')
1081
r2.abort_write_group()
1084
r1._pack_collection.reset()
1086
# r1 has a changed names list, and r2 an open write groups with
1088
# save r1, and then commit the r2 write group, which requires a
1089
# merge to the pack-names, which should not reinstate
1092
r1._pack_collection._save_pack_names()
1093
r1._pack_collection.reset()
1095
r2.abort_write_group()
1098
r2.commit_write_group()
1100
r2.abort_write_group()
1102
# Now both repositories should now about just one name.
1103
r1._pack_collection.ensure_loaded()
1104
r2._pack_collection.ensure_loaded()
1105
self.assertEqual(r1._pack_collection.names(), r2._pack_collection.names())
1106
self.assertEqual(1, len(r1._pack_collection.names()))
1107
self.assertFalse(name_to_drop in r1._pack_collection.names())
1113
def test_lock_write_does_not_physically_lock(self):
1114
repo = self.make_repository('.', format=self.get_format())
1116
self.addCleanup(repo.unlock)
1117
self.assertFalse(repo.get_physical_lock_status())
1119
def prepare_for_break_lock(self):
1120
# Setup the global ui factory state so that a break-lock method call
1121
# will find usable input in the input stream.
1122
old_factory = bzrlib.ui.ui_factory
1123
def restoreFactory():
1124
bzrlib.ui.ui_factory = old_factory
1125
self.addCleanup(restoreFactory)
1126
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1127
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
1129
def test_break_lock_breaks_physical_lock(self):
1130
repo = self.make_repository('.', format=self.get_format())
1131
repo._pack_collection.lock_names()
1132
repo2 = repository.Repository.open('.')
1133
self.assertTrue(repo.get_physical_lock_status())
1134
self.prepare_for_break_lock()
1136
self.assertFalse(repo.get_physical_lock_status())
1138
def test_broken_physical_locks_error_on__unlock_names_lock(self):
1139
repo = self.make_repository('.', format=self.get_format())
1140
repo._pack_collection.lock_names()
1141
self.assertTrue(repo.get_physical_lock_status())
1142
repo2 = repository.Repository.open('.')
1143
self.prepare_for_break_lock()
1145
self.assertRaises(errors.LockBroken, repo._pack_collection._unlock_names)
1147
def test_fetch_without_find_ghosts_ignores_ghosts(self):
1148
# we want two repositories at this point:
1149
# one with a revision that is a ghost in the other
1151
# 'ghost' is present in has_ghost, 'ghost' is absent in 'missing_ghost'.
1152
# 'references' is present in both repositories, and 'tip' is present
1153
# just in has_ghost.
1154
# has_ghost missing_ghost
1155
#------------------------------
1157
# 'references' 'references'
1159
# In this test we fetch 'tip' which should not fetch 'ghost'
1160
has_ghost = self.make_repository('has_ghost', format=self.get_format())
1161
missing_ghost = self.make_repository('missing_ghost',
1162
format=self.get_format())
1164
def add_commit(repo, revision_id, parent_ids):
1166
repo.start_write_group()
1167
inv = inventory.Inventory(revision_id=revision_id)
1168
inv.root.revision = revision_id
1169
root_id = inv.root.file_id
1170
sha1 = repo.add_inventory(revision_id, inv, [])
1171
vf = repo.weave_store.get_weave_or_empty(root_id,
1172
repo.get_transaction())
1173
vf.add_lines(revision_id, [], [])
1174
rev = bzrlib.revision.Revision(timestamp=0,
1176
committer="Foo Bar <foo@example.com>",
1178
inventory_sha1=sha1,
1179
revision_id=revision_id)
1180
rev.parent_ids = parent_ids
1181
repo.add_revision(revision_id, rev)
1182
repo.commit_write_group()
1184
add_commit(has_ghost, 'ghost', [])
1185
add_commit(has_ghost, 'references', ['ghost'])
1186
add_commit(missing_ghost, 'references', ['ghost'])
1187
add_commit(has_ghost, 'tip', ['references'])
1188
missing_ghost.fetch(has_ghost, 'tip')
1189
# missing ghost now has tip and not ghost.
1190
rev = missing_ghost.get_revision('tip')
1191
inv = missing_ghost.get_inventory('tip')
1192
self.assertRaises(errors.NoSuchRevision,
1193
missing_ghost.get_revision, 'ghost')
1194
self.assertRaises(errors.RevisionNotPresent,
1195
missing_ghost.get_inventory, 'ghost')
1197
def test_supports_external_lookups(self):
1198
repo = self.make_repository('.', format=self.get_format())
1199
self.assertFalse(repo._format.supports_external_lookups)
1202
class TestKnitPackSubtrees(TestKnitPackNoSubtrees):
1204
def get_format(self):
1205
return bzrdir.format_registry.make_bzrdir(
1206
'pack-0.92-subtree')
1208
def check_format(self, t):
1209
self.assertEqualDiff(
1210
"Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n",
1211
t.get('format').read())
1214
class TestDevelopment0(TestKnitPackNoSubtrees):
1216
def get_format(self):
1217
return bzrdir.format_registry.make_bzrdir(
1220
def check_format(self, t):
1221
self.assertEqualDiff(
1222
"Bazaar development format 0 (needs bzr.dev from before 1.3)\n",
1223
t.get('format').read())
1226
class TestDevelopment0Subtree(TestKnitPackNoSubtrees):
1228
def get_format(self):
1229
return bzrdir.format_registry.make_bzrdir(
1230
'development-subtree')
1232
def check_format(self, t):
1233
self.assertEqualDiff(
1234
"Bazaar development format 0 with subtree support "
1235
"(needs bzr.dev from before 1.3)\n",
1236
t.get('format').read())
1239
class TestRepositoryPackCollection(TestCaseWithTransport):
1241
def get_format(self):
1242
return bzrdir.format_registry.make_bzrdir('pack-0.92')
1244
def test__max_pack_count(self):
1245
"""The maximum pack count is a function of the number of revisions."""
1246
format = self.get_format()
1247
repo = self.make_repository('.', format=format)
1248
packs = repo._pack_collection
1249
# no revisions - one pack, so that we can have a revision free repo
1250
# without it blowing up
1251
self.assertEqual(1, packs._max_pack_count(0))
1252
# after that the sum of the digits, - check the first 1-9
1253
self.assertEqual(1, packs._max_pack_count(1))
1254
self.assertEqual(2, packs._max_pack_count(2))
1255
self.assertEqual(3, packs._max_pack_count(3))
1256
self.assertEqual(4, packs._max_pack_count(4))
1257
self.assertEqual(5, packs._max_pack_count(5))
1258
self.assertEqual(6, packs._max_pack_count(6))
1259
self.assertEqual(7, packs._max_pack_count(7))
1260
self.assertEqual(8, packs._max_pack_count(8))
1261
self.assertEqual(9, packs._max_pack_count(9))
1262
# check the boundary cases with two digits for the next decade
1263
self.assertEqual(1, packs._max_pack_count(10))
1264
self.assertEqual(2, packs._max_pack_count(11))
1265
self.assertEqual(10, packs._max_pack_count(19))
1266
self.assertEqual(2, packs._max_pack_count(20))
1267
self.assertEqual(3, packs._max_pack_count(21))
1268
# check some arbitrary big numbers
1269
self.assertEqual(25, packs._max_pack_count(112894))
1271
def test_pack_distribution_zero(self):
1272
format = self.get_format()
1273
repo = self.make_repository('.', format=format)
1274
packs = repo._pack_collection
1275
self.assertEqual([0], packs.pack_distribution(0))
1277
def test_ensure_loaded_unlocked(self):
1278
format = self.get_format()
1279
repo = self.make_repository('.', format=format)
1280
self.assertRaises(errors.ObjectNotLocked,
1281
repo._pack_collection.ensure_loaded)
1283
def test_pack_distribution_one_to_nine(self):
1284
format = self.get_format()
1285
repo = self.make_repository('.', format=format)
1286
packs = repo._pack_collection
1287
self.assertEqual([1],
1288
packs.pack_distribution(1))
1289
self.assertEqual([1, 1],
1290
packs.pack_distribution(2))
1291
self.assertEqual([1, 1, 1],
1292
packs.pack_distribution(3))
1293
self.assertEqual([1, 1, 1, 1],
1294
packs.pack_distribution(4))
1295
self.assertEqual([1, 1, 1, 1, 1],
1296
packs.pack_distribution(5))
1297
self.assertEqual([1, 1, 1, 1, 1, 1],
1298
packs.pack_distribution(6))
1299
self.assertEqual([1, 1, 1, 1, 1, 1, 1],
1300
packs.pack_distribution(7))
1301
self.assertEqual([1, 1, 1, 1, 1, 1, 1, 1],
1302
packs.pack_distribution(8))
1303
self.assertEqual([1, 1, 1, 1, 1, 1, 1, 1, 1],
1304
packs.pack_distribution(9))
1306
def test_pack_distribution_stable_at_boundaries(self):
1307
"""When there are multi-rev packs the counts are stable."""
1308
format = self.get_format()
1309
repo = self.make_repository('.', format=format)
1310
packs = repo._pack_collection
1312
self.assertEqual([10], packs.pack_distribution(10))
1313
self.assertEqual([10, 1], packs.pack_distribution(11))
1314
self.assertEqual([10, 10], packs.pack_distribution(20))
1315
self.assertEqual([10, 10, 1], packs.pack_distribution(21))
1317
self.assertEqual([100], packs.pack_distribution(100))
1318
self.assertEqual([100, 1], packs.pack_distribution(101))
1319
self.assertEqual([100, 10, 1], packs.pack_distribution(111))
1320
self.assertEqual([100, 100], packs.pack_distribution(200))
1321
self.assertEqual([100, 100, 1], packs.pack_distribution(201))
1322
self.assertEqual([100, 100, 10, 1], packs.pack_distribution(211))
1324
def test_plan_pack_operations_2009_revisions_skip_all_packs(self):
1325
format = self.get_format()
1326
repo = self.make_repository('.', format=format)
1327
packs = repo._pack_collection
1328
existing_packs = [(2000, "big"), (9, "medium")]
1329
# rev count - 2009 -> 2x1000 + 9x1
1330
pack_operations = packs.plan_autopack_combinations(
1331
existing_packs, [1000, 1000, 1, 1, 1, 1, 1, 1, 1, 1, 1])
1332
self.assertEqual([], pack_operations)
1334
def test_plan_pack_operations_2010_revisions_skip_all_packs(self):
1335
format = self.get_format()
1336
repo = self.make_repository('.', format=format)
1337
packs = repo._pack_collection
1338
existing_packs = [(2000, "big"), (9, "medium"), (1, "single")]
1339
# rev count - 2010 -> 2x1000 + 1x10
1340
pack_operations = packs.plan_autopack_combinations(
1341
existing_packs, [1000, 1000, 10])
1342
self.assertEqual([], pack_operations)
1344
def test_plan_pack_operations_2010_combines_smallest_two(self):
1345
format = self.get_format()
1346
repo = self.make_repository('.', format=format)
1347
packs = repo._pack_collection
1348
existing_packs = [(1999, "big"), (9, "medium"), (1, "single2"),
1350
# rev count - 2010 -> 2x1000 + 1x10 (3)
1351
pack_operations = packs.plan_autopack_combinations(
1352
existing_packs, [1000, 1000, 10])
1353
self.assertEqual([[2, ["single2", "single1"]], [0, []]], pack_operations)
1355
def test_all_packs_none(self):
1356
format = self.get_format()
1357
tree = self.make_branch_and_tree('.', format=format)
1359
self.addCleanup(tree.unlock)
1360
packs = tree.branch.repository._pack_collection
1361
packs.ensure_loaded()
1362
self.assertEqual([], packs.all_packs())
1364
def test_all_packs_one(self):
1365
format = self.get_format()
1366
tree = self.make_branch_and_tree('.', format=format)
1367
tree.commit('start')
1369
self.addCleanup(tree.unlock)
1370
packs = tree.branch.repository._pack_collection
1371
packs.ensure_loaded()
1373
packs.get_pack_by_name(packs.names()[0])],
1376
def test_all_packs_two(self):
1377
format = self.get_format()
1378
tree = self.make_branch_and_tree('.', format=format)
1379
tree.commit('start')
1380
tree.commit('continue')
1382
self.addCleanup(tree.unlock)
1383
packs = tree.branch.repository._pack_collection
1384
packs.ensure_loaded()
1386
packs.get_pack_by_name(packs.names()[0]),
1387
packs.get_pack_by_name(packs.names()[1]),
1388
], packs.all_packs())
1390
def test_get_pack_by_name(self):
1391
format = self.get_format()
1392
tree = self.make_branch_and_tree('.', format=format)
1393
tree.commit('start')
1395
self.addCleanup(tree.unlock)
1396
packs = tree.branch.repository._pack_collection
1397
packs.ensure_loaded()
1398
name = packs.names()[0]
1399
pack_1 = packs.get_pack_by_name(name)
1400
# the pack should be correctly initialised
1401
rev_index = GraphIndex(packs._index_transport, name + '.rix',
1402
packs._names[name][0])
1403
inv_index = GraphIndex(packs._index_transport, name + '.iix',
1404
packs._names[name][1])
1405
txt_index = GraphIndex(packs._index_transport, name + '.tix',
1406
packs._names[name][2])
1407
sig_index = GraphIndex(packs._index_transport, name + '.six',
1408
packs._names[name][3])
1409
self.assertEqual(pack_repo.ExistingPack(packs._pack_transport,
1410
name, rev_index, inv_index, txt_index, sig_index), pack_1)
1411
# and the same instance should be returned on successive calls.
1412
self.assertTrue(pack_1 is packs.get_pack_by_name(name))
1415
class TestPack(TestCaseWithTransport):
1416
"""Tests for the Pack object."""
1418
def assertCurrentlyEqual(self, left, right):
1419
self.assertTrue(left == right)
1420
self.assertTrue(right == left)
1421
self.assertFalse(left != right)
1422
self.assertFalse(right != left)
1424
def assertCurrentlyNotEqual(self, left, right):
1425
self.assertFalse(left == right)
1426
self.assertFalse(right == left)
1427
self.assertTrue(left != right)
1428
self.assertTrue(right != left)
1430
def test___eq____ne__(self):
1431
left = pack_repo.ExistingPack('', '', '', '', '', '')
1432
right = pack_repo.ExistingPack('', '', '', '', '', '')
1433
self.assertCurrentlyEqual(left, right)
1434
# change all attributes and ensure equality changes as we do.
1435
left.revision_index = 'a'
1436
self.assertCurrentlyNotEqual(left, right)
1437
right.revision_index = 'a'
1438
self.assertCurrentlyEqual(left, right)
1439
left.inventory_index = 'a'
1440
self.assertCurrentlyNotEqual(left, right)
1441
right.inventory_index = 'a'
1442
self.assertCurrentlyEqual(left, right)
1443
left.text_index = 'a'
1444
self.assertCurrentlyNotEqual(left, right)
1445
right.text_index = 'a'
1446
self.assertCurrentlyEqual(left, right)
1447
left.signature_index = 'a'
1448
self.assertCurrentlyNotEqual(left, right)
1449
right.signature_index = 'a'
1450
self.assertCurrentlyEqual(left, right)
1452
self.assertCurrentlyNotEqual(left, right)
1454
self.assertCurrentlyEqual(left, right)
1455
left.transport = 'a'
1456
self.assertCurrentlyNotEqual(left, right)
1457
right.transport = 'a'
1458
self.assertCurrentlyEqual(left, right)
1460
def test_file_name(self):
1461
pack = pack_repo.ExistingPack('', 'a_name', '', '', '', '')
1462
self.assertEqual('a_name.pack', pack.file_name())
1465
class TestNewPack(TestCaseWithTransport):
1466
"""Tests for pack_repo.NewPack."""
1468
def test_new_instance_attributes(self):
1469
upload_transport = self.get_transport('upload')
1470
pack_transport = self.get_transport('pack')
1471
index_transport = self.get_transport('index')
1472
upload_transport.mkdir('.')
1473
pack = pack_repo.NewPack(upload_transport, index_transport,
1475
self.assertIsInstance(pack.revision_index, InMemoryGraphIndex)
1476
self.assertIsInstance(pack.inventory_index, InMemoryGraphIndex)
1477
self.assertIsInstance(pack._hash, type(md5.new()))
1478
self.assertTrue(pack.upload_transport is upload_transport)
1479
self.assertTrue(pack.index_transport is index_transport)
1480
self.assertTrue(pack.pack_transport is pack_transport)
1481
self.assertEqual(None, pack.index_sizes)
1482
self.assertEqual(20, len(pack.random_name))
1483
self.assertIsInstance(pack.random_name, str)
1484
self.assertIsInstance(pack.start_time, float)
1487
class TestPacker(TestCaseWithTransport):
1488
"""Tests for the packs repository Packer class."""
1490
# To date, this class has been factored out and nothing new added to it;
1491
# thus there are not yet any tests.
1494
class TestInterDifferingSerializer(TestCaseWithTransport):
1496
def test_progress_bar(self):
1497
tree = self.make_branch_and_tree('tree')
1498
tree.commit('rev1', rev_id='rev-1')
1499
tree.commit('rev2', rev_id='rev-2')
1500
tree.commit('rev3', rev_id='rev-3')
1501
repo = self.make_repository('repo')
1502
inter_repo = repository.InterDifferingSerializer(
1503
tree.branch.repository, repo)
1504
pb = progress.InstrumentedProgress(to_file=StringIO())
1505
pb.never_throttle = True
1506
inter_repo.fetch('rev-1', pb)
1507
self.assertEqual('Transferring revisions', pb.last_msg)
1508
self.assertEqual(1, pb.last_cnt)
1509
self.assertEqual(1, pb.last_total)
1510
inter_repo.fetch('rev-3', pb)
1511
self.assertEqual(2, pb.last_cnt)
1512
self.assertEqual(2, pb.last_total)
added
removed
bzrlib/tests/test_repository.py
