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,
45
from bzrlib.transport import (
49
from bzrlib.transport.memory import MemoryServer
50
from bzrlib.util import bencode
57
revision as _mod_revision,
62
from bzrlib.repofmt import knitrepo, weaverepo, pack_repo
65
class TestDefaultFormat(TestCase):
67
def test_get_set_default_format(self):
68
old_default = bzrdir.format_registry.get('default')
69
private_default = old_default().repository_format.__class__
70
old_format = repository.RepositoryFormat.get_default_format()
71
self.assertTrue(isinstance(old_format, private_default))
72
def make_sample_bzrdir():
73
my_bzrdir = bzrdir.BzrDirMetaFormat1()
74
my_bzrdir.repository_format = SampleRepositoryFormat()
76
bzrdir.format_registry.remove('default')
77
bzrdir.format_registry.register('sample', make_sample_bzrdir, '')
78
bzrdir.format_registry.set_default('sample')
79
# creating a repository should now create an instrumented dir.
81
# the default branch format is used by the meta dir format
82
# which is not the default bzrdir format at this point
83
dir = bzrdir.BzrDirMetaFormat1().initialize('memory:///')
84
result = dir.create_repository()
85
self.assertEqual(result, 'A bzr repository dir')
87
bzrdir.format_registry.remove('default')
88
bzrdir.format_registry.remove('sample')
89
bzrdir.format_registry.register('default', old_default, '')
90
self.assertIsInstance(repository.RepositoryFormat.get_default_format(),
94
class SampleRepositoryFormat(repository.RepositoryFormat):
97
this format is initializable, unsupported to aid in testing the
98
open and open(unsupported=True) routines.
101
def get_format_string(self):
102
"""See RepositoryFormat.get_format_string()."""
103
return "Sample .bzr repository format."
105
def initialize(self, a_bzrdir, shared=False):
106
"""Initialize a repository in a BzrDir"""
107
t = a_bzrdir.get_repository_transport(self)
108
t.put_bytes('format', self.get_format_string())
109
return 'A bzr repository dir'
111
def is_supported(self):
114
def open(self, a_bzrdir, _found=False):
115
return "opened repository."
118
class TestRepositoryFormat(TestCaseWithTransport):
119
"""Tests for the Repository format detection used by the bzr meta dir facility.BzrBranchFormat facility."""
121
def test_find_format(self):
122
# is the right format object found for a repository?
123
# create a branch with a few known format objects.
124
# this is not quite the same as
125
self.build_tree(["foo/", "bar/"])
126
def check_format(format, url):
127
dir = format._matchingbzrdir.initialize(url)
128
format.initialize(dir)
129
t = get_transport(url)
130
found_format = repository.RepositoryFormat.find_format(dir)
131
self.failUnless(isinstance(found_format, format.__class__))
132
check_format(weaverepo.RepositoryFormat7(), "bar")
134
def test_find_format_no_repository(self):
135
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
136
self.assertRaises(errors.NoRepositoryPresent,
137
repository.RepositoryFormat.find_format,
140
def test_find_format_unknown_format(self):
141
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
142
SampleRepositoryFormat().initialize(dir)
143
self.assertRaises(UnknownFormatError,
144
repository.RepositoryFormat.find_format,
147
def test_register_unregister_format(self):
148
format = SampleRepositoryFormat()
150
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
152
format.initialize(dir)
153
# register a format for it.
154
repository.RepositoryFormat.register_format(format)
155
# which repository.Open will refuse (not supported)
156
self.assertRaises(UnsupportedFormatError, repository.Repository.open, self.get_url())
157
# but open(unsupported) will work
158
self.assertEqual(format.open(dir), "opened repository.")
159
# unregister the format
160
repository.RepositoryFormat.unregister_format(format)
163
class TestFormat6(TestCaseWithTransport):
165
def test_attribute__fetch_order(self):
166
"""Weaves need topological data insertion."""
167
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
168
repo = weaverepo.RepositoryFormat6().initialize(control)
169
self.assertEqual('topological', repo._fetch_order)
171
def test_attribute__fetch_uses_deltas(self):
172
"""Weaves do not reuse deltas."""
173
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
174
repo = weaverepo.RepositoryFormat6().initialize(control)
175
self.assertEqual(False, repo._fetch_uses_deltas)
177
def test_attribute__fetch_reconcile(self):
178
"""Weave repositories need a reconcile after fetch."""
179
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
180
repo = weaverepo.RepositoryFormat6().initialize(control)
181
self.assertEqual(True, repo._fetch_reconcile)
183
def test_no_ancestry_weave(self):
184
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
185
repo = weaverepo.RepositoryFormat6().initialize(control)
186
# We no longer need to create the ancestry.weave file
187
# since it is *never* used.
188
self.assertRaises(NoSuchFile,
189
control.transport.get,
192
def test_supports_external_lookups(self):
193
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
194
repo = weaverepo.RepositoryFormat6().initialize(control)
195
self.assertFalse(repo._format.supports_external_lookups)
198
class TestFormat7(TestCaseWithTransport):
200
def test_attribute__fetch_order(self):
201
"""Weaves need topological data insertion."""
202
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
203
repo = weaverepo.RepositoryFormat7().initialize(control)
204
self.assertEqual('topological', repo._fetch_order)
206
def test_attribute__fetch_uses_deltas(self):
207
"""Weaves do not reuse deltas."""
208
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
209
repo = weaverepo.RepositoryFormat7().initialize(control)
210
self.assertEqual(False, repo._fetch_uses_deltas)
212
def test_attribute__fetch_reconcile(self):
213
"""Weave repositories need a reconcile after fetch."""
214
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
215
repo = weaverepo.RepositoryFormat7().initialize(control)
216
self.assertEqual(True, repo._fetch_reconcile)
218
def test_disk_layout(self):
219
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
220
repo = weaverepo.RepositoryFormat7().initialize(control)
221
# in case of side effects of locking.
225
# format 'Bazaar-NG Repository format 7'
227
# inventory.weave == empty_weave
228
# empty revision-store directory
229
# empty weaves directory
230
t = control.get_repository_transport(None)
231
self.assertEqualDiff('Bazaar-NG Repository format 7',
232
t.get('format').read())
233
self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
234
self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
235
self.assertEqualDiff('# bzr weave file v5\n'
238
t.get('inventory.weave').read())
239
# Creating a file with id Foo:Bar results in a non-escaped file name on
241
control.create_branch()
242
tree = control.create_workingtree()
243
tree.add(['foo'], ['Foo:Bar'], ['file'])
244
tree.put_file_bytes_non_atomic('Foo:Bar', 'content\n')
245
tree.commit('first post', rev_id='first')
246
self.assertEqualDiff(
247
'# bzr weave file v5\n'
249
'1 7fe70820e08a1aac0ef224d9c66ab66831cc4ab1\n'
257
t.get('weaves/74/Foo%3ABar.weave').read())
259
def test_shared_disk_layout(self):
260
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
261
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
263
# format 'Bazaar-NG Repository format 7'
264
# inventory.weave == empty_weave
265
# empty revision-store directory
266
# empty weaves directory
267
# a 'shared-storage' marker file.
268
# lock is not present when unlocked
269
t = control.get_repository_transport(None)
270
self.assertEqualDiff('Bazaar-NG Repository format 7',
271
t.get('format').read())
272
self.assertEqualDiff('', t.get('shared-storage').read())
273
self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
274
self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
275
self.assertEqualDiff('# bzr weave file v5\n'
278
t.get('inventory.weave').read())
279
self.assertFalse(t.has('branch-lock'))
281
def test_creates_lockdir(self):
282
"""Make sure it appears to be controlled by a LockDir existence"""
283
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
284
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
285
t = control.get_repository_transport(None)
286
# TODO: Should check there is a 'lock' toplevel directory,
287
# regardless of contents
288
self.assertFalse(t.has('lock/held/info'))
291
self.assertTrue(t.has('lock/held/info'))
293
# unlock so we don't get a warning about failing to do so
296
def test_uses_lockdir(self):
297
"""repo format 7 actually locks on lockdir"""
298
base_url = self.get_url()
299
control = bzrdir.BzrDirMetaFormat1().initialize(base_url)
300
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
301
t = control.get_repository_transport(None)
305
# make sure the same lock is created by opening it
306
repo = repository.Repository.open(base_url)
308
self.assertTrue(t.has('lock/held/info'))
310
self.assertFalse(t.has('lock/held/info'))
312
def test_shared_no_tree_disk_layout(self):
313
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
314
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
315
repo.set_make_working_trees(False)
317
# format 'Bazaar-NG Repository format 7'
319
# inventory.weave == empty_weave
320
# empty revision-store directory
321
# empty weaves directory
322
# a 'shared-storage' marker file.
323
t = control.get_repository_transport(None)
324
self.assertEqualDiff('Bazaar-NG Repository format 7',
325
t.get('format').read())
326
## self.assertEqualDiff('', t.get('lock').read())
327
self.assertEqualDiff('', t.get('shared-storage').read())
328
self.assertEqualDiff('', t.get('no-working-trees').read())
329
repo.set_make_working_trees(True)
330
self.assertFalse(t.has('no-working-trees'))
331
self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
332
self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
333
self.assertEqualDiff('# bzr weave file v5\n'
336
t.get('inventory.weave').read())
338
def test_supports_external_lookups(self):
339
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
340
repo = weaverepo.RepositoryFormat7().initialize(control)
341
self.assertFalse(repo._format.supports_external_lookups)
344
class TestFormatKnit1(TestCaseWithTransport):
346
def test_attribute__fetch_order(self):
347
"""Knits need topological data insertion."""
348
repo = self.make_repository('.',
349
format=bzrdir.format_registry.get('knit')())
350
self.assertEqual('topological', repo._fetch_order)
352
def test_attribute__fetch_uses_deltas(self):
353
"""Knits reuse deltas."""
354
repo = self.make_repository('.',
355
format=bzrdir.format_registry.get('knit')())
356
self.assertEqual(True, repo._fetch_uses_deltas)
358
def test_disk_layout(self):
359
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
360
repo = knitrepo.RepositoryFormatKnit1().initialize(control)
361
# in case of side effects of locking.
365
# format 'Bazaar-NG Knit Repository Format 1'
366
# lock: is a directory
367
# inventory.weave == empty_weave
368
# empty revision-store directory
369
# empty weaves directory
370
t = control.get_repository_transport(None)
371
self.assertEqualDiff('Bazaar-NG Knit Repository Format 1',
372
t.get('format').read())
373
# XXX: no locks left when unlocked at the moment
374
# self.assertEqualDiff('', t.get('lock').read())
375
self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
377
# Check per-file knits.
378
branch = control.create_branch()
379
tree = control.create_workingtree()
380
tree.add(['foo'], ['Nasty-IdC:'], ['file'])
381
tree.put_file_bytes_non_atomic('Nasty-IdC:', '')
382
tree.commit('1st post', rev_id='foo')
383
self.assertHasKnit(t, 'knits/e8/%254easty-%2549d%2543%253a',
384
'\nfoo fulltext 0 81 :')
386
def assertHasKnit(self, t, knit_name, extra_content=''):
387
"""Assert that knit_name exists on t."""
388
self.assertEqualDiff('# bzr knit index 8\n' + extra_content,
389
t.get(knit_name + '.kndx').read())
391
def check_knits(self, t):
392
"""check knit content for a repository."""
393
self.assertHasKnit(t, 'inventory')
394
self.assertHasKnit(t, 'revisions')
395
self.assertHasKnit(t, 'signatures')
397
def test_shared_disk_layout(self):
398
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
399
repo = knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
401
# format 'Bazaar-NG Knit Repository Format 1'
402
# lock: is a directory
403
# inventory.weave == empty_weave
404
# empty revision-store directory
405
# empty weaves directory
406
# a 'shared-storage' marker file.
407
t = control.get_repository_transport(None)
408
self.assertEqualDiff('Bazaar-NG Knit Repository Format 1',
409
t.get('format').read())
410
# XXX: no locks left when unlocked at the moment
411
# self.assertEqualDiff('', t.get('lock').read())
412
self.assertEqualDiff('', t.get('shared-storage').read())
413
self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
416
def test_shared_no_tree_disk_layout(self):
417
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
418
repo = knitrepo.RepositoryFormatKnit1().initialize(control, shared=True)
419
repo.set_make_working_trees(False)
421
# format 'Bazaar-NG Knit Repository Format 1'
423
# inventory.weave == empty_weave
424
# empty revision-store directory
425
# empty weaves directory
426
# a 'shared-storage' marker file.
427
t = control.get_repository_transport(None)
428
self.assertEqualDiff('Bazaar-NG Knit Repository Format 1',
429
t.get('format').read())
430
# XXX: no locks left when unlocked at the moment
431
# self.assertEqualDiff('', t.get('lock').read())
432
self.assertEqualDiff('', t.get('shared-storage').read())
433
self.assertEqualDiff('', t.get('no-working-trees').read())
434
repo.set_make_working_trees(True)
435
self.assertFalse(t.has('no-working-trees'))
436
self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
439
def test_deserialise_sets_root_revision(self):
440
"""We must have a inventory.root.revision
442
Old versions of the XML5 serializer did not set the revision_id for
443
the whole inventory. So we grab the one from the expected text. Which
444
is valid when the api is not being abused.
446
repo = self.make_repository('.',
447
format=bzrdir.format_registry.get('knit')())
448
inv_xml = '<inventory format="5">\n</inventory>\n'
449
inv = repo.deserialise_inventory('test-rev-id', inv_xml)
450
self.assertEqual('test-rev-id', inv.root.revision)
452
def test_deserialise_uses_global_revision_id(self):
453
"""If it is set, then we re-use the global revision id"""
454
repo = self.make_repository('.',
455
format=bzrdir.format_registry.get('knit')())
456
inv_xml = ('<inventory format="5" revision_id="other-rev-id">\n'
458
# Arguably, the deserialise_inventory should detect a mismatch, and
459
# raise an error, rather than silently using one revision_id over the
461
self.assertRaises(AssertionError, repo.deserialise_inventory,
462
'test-rev-id', inv_xml)
463
inv = repo.deserialise_inventory('other-rev-id', inv_xml)
464
self.assertEqual('other-rev-id', inv.root.revision)
466
def test_supports_external_lookups(self):
467
repo = self.make_repository('.',
468
format=bzrdir.format_registry.get('knit')())
469
self.assertFalse(repo._format.supports_external_lookups)
472
class DummyRepository(object):
473
"""A dummy repository for testing."""
477
def supports_rich_root(self):
481
class InterDummy(repository.InterRepository):
482
"""An inter-repository optimised code path for DummyRepository.
484
This is for use during testing where we use DummyRepository as repositories
485
so that none of the default regsitered inter-repository classes will
490
def is_compatible(repo_source, repo_target):
491
"""InterDummy is compatible with DummyRepository."""
492
return (isinstance(repo_source, DummyRepository) and
493
isinstance(repo_target, DummyRepository))
496
class TestInterRepository(TestCaseWithTransport):
498
def test_get_default_inter_repository(self):
499
# test that the InterRepository.get(repo_a, repo_b) probes
500
# for a inter_repo class where is_compatible(repo_a, repo_b) returns
501
# true and returns a default inter_repo otherwise.
502
# This also tests that the default registered optimised interrepository
503
# classes do not barf inappropriately when a surprising repository type
505
dummy_a = DummyRepository()
506
dummy_b = DummyRepository()
507
self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
509
def assertGetsDefaultInterRepository(self, repo_a, repo_b):
510
"""Asserts that InterRepository.get(repo_a, repo_b) -> the default.
512
The effective default is now InterSameDataRepository because there is
513
no actual sane default in the presence of incompatible data models.
515
inter_repo = repository.InterRepository.get(repo_a, repo_b)
516
self.assertEqual(repository.InterSameDataRepository,
517
inter_repo.__class__)
518
self.assertEqual(repo_a, inter_repo.source)
519
self.assertEqual(repo_b, inter_repo.target)
521
def test_register_inter_repository_class(self):
522
# test that a optimised code path provider - a
523
# InterRepository subclass can be registered and unregistered
524
# and that it is correctly selected when given a repository
525
# pair that it returns true on for the is_compatible static method
527
dummy_a = DummyRepository()
528
dummy_b = DummyRepository()
529
repo = self.make_repository('.')
530
# hack dummies to look like repo somewhat.
531
dummy_a._serializer = repo._serializer
532
dummy_b._serializer = repo._serializer
533
repository.InterRepository.register_optimiser(InterDummy)
535
# we should get the default for something InterDummy returns False
537
self.assertFalse(InterDummy.is_compatible(dummy_a, repo))
538
self.assertGetsDefaultInterRepository(dummy_a, repo)
539
# and we should get an InterDummy for a pair it 'likes'
540
self.assertTrue(InterDummy.is_compatible(dummy_a, dummy_b))
541
inter_repo = repository.InterRepository.get(dummy_a, dummy_b)
542
self.assertEqual(InterDummy, inter_repo.__class__)
543
self.assertEqual(dummy_a, inter_repo.source)
544
self.assertEqual(dummy_b, inter_repo.target)
546
repository.InterRepository.unregister_optimiser(InterDummy)
547
# now we should get the default InterRepository object again.
548
self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
551
class TestInterWeaveRepo(TestCaseWithTransport):
553
def test_is_compatible_and_registered(self):
554
# InterWeaveRepo is compatible when either side
555
# is a format 5/6/7 branch
556
from bzrlib.repofmt import knitrepo, weaverepo
557
formats = [weaverepo.RepositoryFormat5(),
558
weaverepo.RepositoryFormat6(),
559
weaverepo.RepositoryFormat7()]
560
incompatible_formats = [weaverepo.RepositoryFormat4(),
561
knitrepo.RepositoryFormatKnit1(),
563
repo_a = self.make_repository('a')
564
repo_b = self.make_repository('b')
565
is_compatible = repository.InterWeaveRepo.is_compatible
566
for source in incompatible_formats:
567
# force incompatible left then right
568
repo_a._format = source
569
repo_b._format = formats[0]
570
self.assertFalse(is_compatible(repo_a, repo_b))
571
self.assertFalse(is_compatible(repo_b, repo_a))
572
for source in formats:
573
repo_a._format = source
574
for target in formats:
575
repo_b._format = target
576
self.assertTrue(is_compatible(repo_a, repo_b))
577
self.assertEqual(repository.InterWeaveRepo,
578
repository.InterRepository.get(repo_a,
582
class TestRepositoryConverter(TestCaseWithTransport):
584
def test_convert_empty(self):
585
t = get_transport(self.get_url('.'))
586
t.mkdir('repository')
587
repo_dir = bzrdir.BzrDirMetaFormat1().initialize('repository')
588
repo = weaverepo.RepositoryFormat7().initialize(repo_dir)
589
target_format = knitrepo.RepositoryFormatKnit1()
590
converter = repository.CopyConverter(target_format)
591
pb = bzrlib.ui.ui_factory.nested_progress_bar()
593
converter.convert(repo, pb)
596
repo = repo_dir.open_repository()
597
self.assertTrue(isinstance(target_format, repo._format.__class__))
600
class TestMisc(TestCase):
602
def test_unescape_xml(self):
603
"""We get some kind of error when malformed entities are passed"""
604
self.assertRaises(KeyError, repository._unescape_xml, 'foo&bar;')
607
class TestRepositoryFormatKnit3(TestCaseWithTransport):
609
def test_attribute__fetch_order(self):
610
"""Knits need topological data insertion."""
611
format = bzrdir.BzrDirMetaFormat1()
612
format.repository_format = knitrepo.RepositoryFormatKnit3()
613
repo = self.make_repository('.', format=format)
614
self.assertEqual('topological', repo._fetch_order)
616
def test_attribute__fetch_uses_deltas(self):
617
"""Knits reuse deltas."""
618
format = bzrdir.BzrDirMetaFormat1()
619
format.repository_format = knitrepo.RepositoryFormatKnit3()
620
repo = self.make_repository('.', format=format)
621
self.assertEqual(True, repo._fetch_uses_deltas)
623
def test_convert(self):
624
"""Ensure the upgrade adds weaves for roots"""
625
format = bzrdir.BzrDirMetaFormat1()
626
format.repository_format = knitrepo.RepositoryFormatKnit1()
627
tree = self.make_branch_and_tree('.', format)
628
tree.commit("Dull commit", rev_id="dull")
629
revision_tree = tree.branch.repository.revision_tree('dull')
630
revision_tree.lock_read()
632
self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
633
revision_tree.inventory.root.file_id)
635
revision_tree.unlock()
636
format = bzrdir.BzrDirMetaFormat1()
637
format.repository_format = knitrepo.RepositoryFormatKnit3()
638
upgrade.Convert('.', format)
639
tree = workingtree.WorkingTree.open('.')
640
revision_tree = tree.branch.repository.revision_tree('dull')
641
revision_tree.lock_read()
643
revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
645
revision_tree.unlock()
646
tree.commit("Another dull commit", rev_id='dull2')
647
revision_tree = tree.branch.repository.revision_tree('dull2')
648
revision_tree.lock_read()
649
self.addCleanup(revision_tree.unlock)
650
self.assertEqual('dull', revision_tree.inventory.root.revision)
652
def test_supports_external_lookups(self):
653
format = bzrdir.BzrDirMetaFormat1()
654
format.repository_format = knitrepo.RepositoryFormatKnit3()
655
repo = self.make_repository('.', format=format)
656
self.assertFalse(repo._format.supports_external_lookups)
659
class TestWithBrokenRepo(TestCaseWithTransport):
660
"""These tests seem to be more appropriate as interface tests?"""
662
def make_broken_repository(self):
663
# XXX: This function is borrowed from Aaron's "Reconcile can fix bad
664
# parent references" branch which is due to land in bzr.dev soon. Once
665
# it does, this duplication should be removed.
666
repo = self.make_repository('broken-repo')
670
cleanups.append(repo.unlock)
671
repo.start_write_group()
672
cleanups.append(repo.commit_write_group)
673
# make rev1a: A well-formed revision, containing 'file1'
674
inv = inventory.Inventory(revision_id='rev1a')
675
inv.root.revision = 'rev1a'
676
self.add_file(repo, inv, 'file1', 'rev1a', [])
677
repo.add_inventory('rev1a', inv, [])
678
revision = _mod_revision.Revision('rev1a',
679
committer='jrandom@example.com', timestamp=0,
680
inventory_sha1='', timezone=0, message='foo', parent_ids=[])
681
repo.add_revision('rev1a',revision, inv)
683
# make rev1b, which has no Revision, but has an Inventory, and
685
inv = inventory.Inventory(revision_id='rev1b')
686
inv.root.revision = 'rev1b'
687
self.add_file(repo, inv, 'file1', 'rev1b', [])
688
repo.add_inventory('rev1b', inv, [])
690
# make rev2, with file1 and file2
692
# file1 has 'rev1b' as an ancestor, even though this is not
693
# mentioned by 'rev1a', making it an unreferenced ancestor
694
inv = inventory.Inventory()
695
self.add_file(repo, inv, 'file1', 'rev2', ['rev1a', 'rev1b'])
696
self.add_file(repo, inv, 'file2', 'rev2', [])
697
self.add_revision(repo, 'rev2', inv, ['rev1a'])
699
# make ghost revision rev1c
700
inv = inventory.Inventory()
701
self.add_file(repo, inv, 'file2', 'rev1c', [])
703
# make rev3 with file2
704
# file2 refers to 'rev1c', which is a ghost in this repository, so
705
# file2 cannot have rev1c as its ancestor.
706
inv = inventory.Inventory()
707
self.add_file(repo, inv, 'file2', 'rev3', ['rev1c'])
708
self.add_revision(repo, 'rev3', inv, ['rev1c'])
711
for cleanup in reversed(cleanups):
714
def add_revision(self, repo, revision_id, inv, parent_ids):
715
inv.revision_id = revision_id
716
inv.root.revision = revision_id
717
repo.add_inventory(revision_id, inv, parent_ids)
718
revision = _mod_revision.Revision(revision_id,
719
committer='jrandom@example.com', timestamp=0, inventory_sha1='',
720
timezone=0, message='foo', parent_ids=parent_ids)
721
repo.add_revision(revision_id,revision, inv)
723
def add_file(self, repo, inv, filename, revision, parents):
724
file_id = filename + '-id'
725
entry = inventory.InventoryFile(file_id, filename, 'TREE_ROOT')
726
entry.revision = revision
729
text_key = (file_id, revision)
730
parent_keys = [(file_id, parent) for parent in parents]
731
repo.texts.add_lines(text_key, parent_keys, ['line\n'])
733
def test_insert_from_broken_repo(self):
734
"""Inserting a data stream from a broken repository won't silently
735
corrupt the target repository.
737
broken_repo = self.make_broken_repository()
738
empty_repo = self.make_repository('empty-repo')
739
self.assertRaises(errors.RevisionNotPresent, empty_repo.fetch, broken_repo)
742
class TestKnitPackNoSubtrees(TestCaseWithTransport):
744
def get_format(self):
745
return bzrdir.format_registry.make_bzrdir('pack-0.92')
747
def test_attribute__fetch_order(self):
748
"""Packs do not need ordered data retrieval."""
749
format = self.get_format()
750
repo = self.make_repository('.', format=format)
751
self.assertEqual('unsorted', repo._fetch_order)
753
def test_attribute__fetch_uses_deltas(self):
754
"""Packs reuse deltas."""
755
format = self.get_format()
756
repo = self.make_repository('.', format=format)
757
self.assertEqual(True, repo._fetch_uses_deltas)
759
def test_disk_layout(self):
760
format = self.get_format()
761
repo = self.make_repository('.', format=format)
762
# in case of side effects of locking.
765
t = repo.bzrdir.get_repository_transport(None)
767
# XXX: no locks left when unlocked at the moment
768
# self.assertEqualDiff('', t.get('lock').read())
769
self.check_databases(t)
771
def check_format(self, t):
772
self.assertEqualDiff(
773
"Bazaar pack repository format 1 (needs bzr 0.92)\n",
774
t.get('format').read())
776
def assertHasNoKndx(self, t, knit_name):
777
"""Assert that knit_name has no index on t."""
778
self.assertFalse(t.has(knit_name + '.kndx'))
780
def assertHasNoKnit(self, t, knit_name):
781
"""Assert that knit_name exists on t."""
783
self.assertFalse(t.has(knit_name + '.knit'))
785
def check_databases(self, t):
786
"""check knit content for a repository."""
787
# check conversion worked
788
self.assertHasNoKndx(t, 'inventory')
789
self.assertHasNoKnit(t, 'inventory')
790
self.assertHasNoKndx(t, 'revisions')
791
self.assertHasNoKnit(t, 'revisions')
792
self.assertHasNoKndx(t, 'signatures')
793
self.assertHasNoKnit(t, 'signatures')
794
self.assertFalse(t.has('knits'))
795
# revision-indexes file-container directory
797
list(GraphIndex(t, 'pack-names', None).iter_all_entries()))
798
self.assertTrue(S_ISDIR(t.stat('packs').st_mode))
799
self.assertTrue(S_ISDIR(t.stat('upload').st_mode))
800
self.assertTrue(S_ISDIR(t.stat('indices').st_mode))
801
self.assertTrue(S_ISDIR(t.stat('obsolete_packs').st_mode))
803
def test_shared_disk_layout(self):
804
format = self.get_format()
805
repo = self.make_repository('.', shared=True, format=format)
807
t = repo.bzrdir.get_repository_transport(None)
809
# XXX: no locks left when unlocked at the moment
810
# self.assertEqualDiff('', t.get('lock').read())
811
# We should have a 'shared-storage' marker file.
812
self.assertEqualDiff('', t.get('shared-storage').read())
813
self.check_databases(t)
815
def test_shared_no_tree_disk_layout(self):
816
format = self.get_format()
817
repo = self.make_repository('.', shared=True, format=format)
818
repo.set_make_working_trees(False)
820
t = repo.bzrdir.get_repository_transport(None)
822
# XXX: no locks left when unlocked at the moment
823
# self.assertEqualDiff('', t.get('lock').read())
824
# We should have a 'shared-storage' marker file.
825
self.assertEqualDiff('', t.get('shared-storage').read())
826
# We should have a marker for the no-working-trees flag.
827
self.assertEqualDiff('', t.get('no-working-trees').read())
828
# The marker should go when we toggle the setting.
829
repo.set_make_working_trees(True)
830
self.assertFalse(t.has('no-working-trees'))
831
self.check_databases(t)
833
def test_adding_revision_creates_pack_indices(self):
834
format = self.get_format()
835
tree = self.make_branch_and_tree('.', format=format)
836
trans = tree.branch.repository.bzrdir.get_repository_transport(None)
838
list(GraphIndex(trans, 'pack-names', None).iter_all_entries()))
839
tree.commit('foobarbaz')
840
index = GraphIndex(trans, 'pack-names', None)
841
index_nodes = list(index.iter_all_entries())
842
self.assertEqual(1, len(index_nodes))
843
node = index_nodes[0]
845
# the pack sizes should be listed in the index
847
sizes = [int(digits) for digits in pack_value.split(' ')]
848
for size, suffix in zip(sizes, ['.rix', '.iix', '.tix', '.six']):
849
stat = trans.stat('indices/%s%s' % (name, suffix))
850
self.assertEqual(size, stat.st_size)
852
def test_pulling_nothing_leads_to_no_new_names(self):
853
format = self.get_format()
854
tree1 = self.make_branch_and_tree('1', format=format)
855
tree2 = self.make_branch_and_tree('2', format=format)
856
tree1.branch.repository.fetch(tree2.branch.repository)
857
trans = tree1.branch.repository.bzrdir.get_repository_transport(None)
859
list(GraphIndex(trans, 'pack-names', None).iter_all_entries()))
861
def test_commit_across_pack_shape_boundary_autopacks(self):
862
format = self.get_format()
863
tree = self.make_branch_and_tree('.', format=format)
864
trans = tree.branch.repository.bzrdir.get_repository_transport(None)
865
# This test could be a little cheaper by replacing the packs
866
# attribute on the repository to allow a different pack distribution
867
# and max packs policy - so we are checking the policy is honoured
868
# in the test. But for now 11 commits is not a big deal in a single
871
tree.commit('commit %s' % x)
872
# there should be 9 packs:
873
index = GraphIndex(trans, 'pack-names', None)
874
self.assertEqual(9, len(list(index.iter_all_entries())))
875
# insert some files in obsolete_packs which should be removed by pack.
876
trans.put_bytes('obsolete_packs/foo', '123')
877
trans.put_bytes('obsolete_packs/bar', '321')
878
# committing one more should coalesce to 1 of 10.
879
tree.commit('commit triggering pack')
880
index = GraphIndex(trans, 'pack-names', None)
881
self.assertEqual(1, len(list(index.iter_all_entries())))
882
# packing should not damage data
883
tree = tree.bzrdir.open_workingtree()
884
check_result = tree.branch.repository.check(
885
[tree.branch.last_revision()])
886
# We should have 50 (10x5) files in the obsolete_packs directory.
887
obsolete_files = list(trans.list_dir('obsolete_packs'))
888
self.assertFalse('foo' in obsolete_files)
889
self.assertFalse('bar' in obsolete_files)
890
self.assertEqual(50, len(obsolete_files))
891
# XXX: Todo check packs obsoleted correctly - old packs and indices
892
# in the obsolete_packs directory.
893
large_pack_name = list(index.iter_all_entries())[0][1][0]
894
# finally, committing again should not touch the large pack.
895
tree.commit('commit not triggering pack')
896
index = GraphIndex(trans, 'pack-names', None)
897
self.assertEqual(2, len(list(index.iter_all_entries())))
898
pack_names = [node[1][0] for node in index.iter_all_entries()]
899
self.assertTrue(large_pack_name in pack_names)
901
def test_fail_obsolete_deletion(self):
902
# failing to delete obsolete packs is not fatal
903
format = self.get_format()
904
server = fakenfs.FakeNFSServer()
906
self.addCleanup(server.tearDown)
907
transport = get_transport(server.get_url())
908
bzrdir = self.get_format().initialize_on_transport(transport)
909
repo = bzrdir.create_repository()
910
repo_transport = bzrdir.get_repository_transport(None)
911
self.assertTrue(repo_transport.has('obsolete_packs'))
912
# these files are in use by another client and typically can't be deleted
913
repo_transport.put_bytes('obsolete_packs/.nfsblahblah', 'contents')
914
repo._pack_collection._clear_obsolete_packs()
915
self.assertTrue(repo_transport.has('obsolete_packs/.nfsblahblah'))
917
def test_pack_after_two_commits_packs_everything(self):
918
format = self.get_format()
919
tree = self.make_branch_and_tree('.', format=format)
920
trans = tree.branch.repository.bzrdir.get_repository_transport(None)
922
tree.commit('more work')
923
tree.branch.repository.pack()
924
# there should be 1 pack:
925
index = GraphIndex(trans, 'pack-names', None)
926
self.assertEqual(1, len(list(index.iter_all_entries())))
927
self.assertEqual(2, len(tree.branch.repository.all_revision_ids()))
929
def test_pack_layout(self):
930
format = self.get_format()
931
tree = self.make_branch_and_tree('.', format=format)
932
trans = tree.branch.repository.bzrdir.get_repository_transport(None)
933
tree.commit('start', rev_id='1')
934
tree.commit('more work', rev_id='2')
935
tree.branch.repository.pack()
937
self.addCleanup(tree.unlock)
938
pack = tree.branch.repository._pack_collection.get_pack_by_name(
939
tree.branch.repository._pack_collection.names()[0])
940
# revision access tends to be tip->ancestor, so ordering that way on
941
# disk is a good idea.
942
for _1, key, val, refs in pack.revision_index.iter_all_entries():
944
pos_1 = int(val[1:].split()[0])
946
pos_2 = int(val[1:].split()[0])
947
self.assertTrue(pos_2 < pos_1)
949
def test_pack_repositories_support_multiple_write_locks(self):
950
format = self.get_format()
951
self.make_repository('.', shared=True, format=format)
952
r1 = repository.Repository.open('.')
953
r2 = repository.Repository.open('.')
955
self.addCleanup(r1.unlock)
959
def _add_text(self, repo, fileid):
960
"""Add a text to the repository within a write group."""
961
repo.texts.add_lines((fileid, 'samplerev+'+fileid), [], [])
963
def test_concurrent_writers_merge_new_packs(self):
964
format = self.get_format()
965
self.make_repository('.', shared=True, format=format)
966
r1 = repository.Repository.open('.')
967
r2 = repository.Repository.open('.')
970
# access enough data to load the names list
971
list(r1.all_revision_ids())
974
# access enough data to load the names list
975
list(r2.all_revision_ids())
976
r1.start_write_group()
978
r2.start_write_group()
980
self._add_text(r1, 'fileidr1')
981
self._add_text(r2, 'fileidr2')
983
r2.abort_write_group()
986
r1.abort_write_group()
988
# both r1 and r2 have open write groups with data in them
989
# created while the other's write group was open.
990
# Commit both which requires a merge to the pack-names.
992
r1.commit_write_group()
994
r1.abort_write_group()
995
r2.abort_write_group()
997
r2.commit_write_group()
998
# tell r1 to reload from disk
999
r1._pack_collection.reset()
1000
# Now both repositories should know about both names
1001
r1._pack_collection.ensure_loaded()
1002
r2._pack_collection.ensure_loaded()
1003
self.assertEqual(r1._pack_collection.names(), r2._pack_collection.names())
1004
self.assertEqual(2, len(r1._pack_collection.names()))
1010
def test_concurrent_writer_second_preserves_dropping_a_pack(self):
1011
format = self.get_format()
1012
self.make_repository('.', shared=True, format=format)
1013
r1 = repository.Repository.open('.')
1014
r2 = repository.Repository.open('.')
1015
# add a pack to drop
1018
r1.start_write_group()
1020
self._add_text(r1, 'fileidr1')
1022
r1.abort_write_group()
1025
r1.commit_write_group()
1026
r1._pack_collection.ensure_loaded()
1027
name_to_drop = r1._pack_collection.all_packs()[0].name
1032
# access enough data to load the names list
1033
list(r1.all_revision_ids())
1036
# access enough data to load the names list
1037
list(r2.all_revision_ids())
1038
r1._pack_collection.ensure_loaded()
1040
r2.start_write_group()
1042
# in r1, drop the pack
1043
r1._pack_collection._remove_pack_from_memory(
1044
r1._pack_collection.get_pack_by_name(name_to_drop))
1046
self._add_text(r2, 'fileidr2')
1048
r2.abort_write_group()
1051
r1._pack_collection.reset()
1053
# r1 has a changed names list, and r2 an open write groups with
1055
# save r1, and then commit the r2 write group, which requires a
1056
# merge to the pack-names, which should not reinstate
1059
r1._pack_collection._save_pack_names()
1060
r1._pack_collection.reset()
1062
r2.abort_write_group()
1065
r2.commit_write_group()
1067
r2.abort_write_group()
1069
# Now both repositories should now about just one name.
1070
r1._pack_collection.ensure_loaded()
1071
r2._pack_collection.ensure_loaded()
1072
self.assertEqual(r1._pack_collection.names(), r2._pack_collection.names())
1073
self.assertEqual(1, len(r1._pack_collection.names()))
1074
self.assertFalse(name_to_drop in r1._pack_collection.names())
1080
def test_lock_write_does_not_physically_lock(self):
1081
repo = self.make_repository('.', format=self.get_format())
1083
self.addCleanup(repo.unlock)
1084
self.assertFalse(repo.get_physical_lock_status())
1086
def prepare_for_break_lock(self):
1087
# Setup the global ui factory state so that a break-lock method call
1088
# will find usable input in the input stream.
1089
old_factory = bzrlib.ui.ui_factory
1090
def restoreFactory():
1091
bzrlib.ui.ui_factory = old_factory
1092
self.addCleanup(restoreFactory)
1093
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1094
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
1096
def test_break_lock_breaks_physical_lock(self):
1097
repo = self.make_repository('.', format=self.get_format())
1098
repo._pack_collection.lock_names()
1099
repo2 = repository.Repository.open('.')
1100
self.assertTrue(repo.get_physical_lock_status())
1101
self.prepare_for_break_lock()
1103
self.assertFalse(repo.get_physical_lock_status())
1105
def test_broken_physical_locks_error_on__unlock_names_lock(self):
1106
repo = self.make_repository('.', format=self.get_format())
1107
repo._pack_collection.lock_names()
1108
self.assertTrue(repo.get_physical_lock_status())
1109
repo2 = repository.Repository.open('.')
1110
self.prepare_for_break_lock()
1112
self.assertRaises(errors.LockBroken, repo._pack_collection._unlock_names)
1114
def test_fetch_without_find_ghosts_ignores_ghosts(self):
1115
# we want two repositories at this point:
1116
# one with a revision that is a ghost in the other
1118
# 'ghost' is present in has_ghost, 'ghost' is absent in 'missing_ghost'.
1119
# 'references' is present in both repositories, and 'tip' is present
1120
# just in has_ghost.
1121
# has_ghost missing_ghost
1122
#------------------------------
1124
# 'references' 'references'
1126
# In this test we fetch 'tip' which should not fetch 'ghost'
1127
has_ghost = self.make_repository('has_ghost', format=self.get_format())
1128
missing_ghost = self.make_repository('missing_ghost',
1129
format=self.get_format())
1131
def add_commit(repo, revision_id, parent_ids):
1133
repo.start_write_group()
1134
inv = inventory.Inventory(revision_id=revision_id)
1135
inv.root.revision = revision_id
1136
root_id = inv.root.file_id
1137
sha1 = repo.add_inventory(revision_id, inv, [])
1138
repo.texts.add_lines((root_id, revision_id), [], [])
1139
rev = bzrlib.revision.Revision(timestamp=0,
1141
committer="Foo Bar <foo@example.com>",
1143
inventory_sha1=sha1,
1144
revision_id=revision_id)
1145
rev.parent_ids = parent_ids
1146
repo.add_revision(revision_id, rev)
1147
repo.commit_write_group()
1149
add_commit(has_ghost, 'ghost', [])
1150
add_commit(has_ghost, 'references', ['ghost'])
1151
add_commit(missing_ghost, 'references', ['ghost'])
1152
add_commit(has_ghost, 'tip', ['references'])
1153
missing_ghost.fetch(has_ghost, 'tip')
1154
# missing ghost now has tip and not ghost.
1155
rev = missing_ghost.get_revision('tip')
1156
inv = missing_ghost.get_inventory('tip')
1157
self.assertRaises(errors.NoSuchRevision,
1158
missing_ghost.get_revision, 'ghost')
1159
self.assertRaises(errors.NoSuchRevision,
1160
missing_ghost.get_inventory, 'ghost')
1162
def test_supports_external_lookups(self):
1163
repo = self.make_repository('.', format=self.get_format())
1164
self.assertFalse(repo._format.supports_external_lookups)
1167
class TestKnitPackSubtrees(TestKnitPackNoSubtrees):
1169
def get_format(self):
1170
return bzrdir.format_registry.make_bzrdir(
1171
'pack-0.92-subtree')
1173
def check_format(self, t):
1174
self.assertEqualDiff(
1175
"Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n",
1176
t.get('format').read())
1179
class TestDevelopment0(TestKnitPackNoSubtrees):
1181
def get_format(self):
1182
return bzrdir.format_registry.make_bzrdir(
1185
def check_format(self, t):
1186
self.assertEqualDiff(
1187
"Bazaar development format 0 (needs bzr.dev from before 1.3)\n",
1188
t.get('format').read())
1191
class TestDevelopment0Subtree(TestKnitPackNoSubtrees):
1193
def get_format(self):
1194
return bzrdir.format_registry.make_bzrdir(
1195
'development0-subtree')
1197
def check_format(self, t):
1198
self.assertEqualDiff(
1199
"Bazaar development format 0 with subtree support "
1200
"(needs bzr.dev from before 1.3)\n",
1201
t.get('format').read())
1204
class TestExternalDevelopment1(object):
1206
# mixin class for testing stack-supporting development formats
1208
def test_compatible_cross_formats(self):
1209
# early versions of the packing code relied on pack internals to
1210
# stack, but the current version should be able to stack on any
1212
repo = self.make_repository('repo', format=self.get_format())
1213
if repo.supports_rich_root():
1214
# can only stack on repositories that have compatible internal
1216
matching_format_name = 'pack-0.92-subtree'
1217
mismatching_format_name = 'pack-0.92'
1219
matching_format_name = 'pack-0.92'
1220
mismatching_format_name = 'pack-0.92-subtree'
1221
base = self.make_repository('base', format=matching_format_name)
1222
repo.add_fallback_repository(base)
1223
# you can't stack on something with incompatible data
1224
bad_repo = self.make_repository('mismatch',
1225
format=mismatching_format_name)
1226
self.assertRaises(errors.IncompatibleRepositories,
1227
repo.add_fallback_repository, bad_repo)
1229
def test_adding_pack_does_not_record_pack_names_from_other_repositories(self):
1230
base = self.make_branch_and_tree('base', format=self.get_format())
1232
referencing = self.make_branch_and_tree('repo', format=self.get_format())
1233
referencing.branch.repository.add_fallback_repository(base.branch.repository)
1234
referencing.commit('bar')
1235
new_instance = referencing.bzrdir.open_repository()
1236
new_instance.lock_read()
1237
self.addCleanup(new_instance.unlock)
1238
new_instance._pack_collection.ensure_loaded()
1239
self.assertEqual(1, len(new_instance._pack_collection.all_packs()))
1241
def test_autopack_only_considers_main_repo_packs(self):
1242
base = self.make_branch_and_tree('base', format=self.get_format())
1244
tree = self.make_branch_and_tree('repo', format=self.get_format())
1245
tree.branch.repository.add_fallback_repository(base.branch.repository)
1246
trans = tree.branch.repository.bzrdir.get_repository_transport(None)
1247
# This test could be a little cheaper by replacing the packs
1248
# attribute on the repository to allow a different pack distribution
1249
# and max packs policy - so we are checking the policy is honoured
1250
# in the test. But for now 11 commits is not a big deal in a single
1253
tree.commit('commit %s' % x)
1254
# there should be 9 packs:
1255
index = GraphIndex(trans, 'pack-names', None)
1256
self.assertEqual(9, len(list(index.iter_all_entries())))
1257
# committing one more should coalesce to 1 of 10.
1258
tree.commit('commit triggering pack')
1259
index = GraphIndex(trans, 'pack-names', None)
1260
self.assertEqual(1, len(list(index.iter_all_entries())))
1261
# packing should not damage data
1262
tree = tree.bzrdir.open_workingtree()
1263
check_result = tree.branch.repository.check(
1264
[tree.branch.last_revision()])
1265
# We should have 50 (10x5) files in the obsolete_packs directory.
1266
obsolete_files = list(trans.list_dir('obsolete_packs'))
1267
self.assertFalse('foo' in obsolete_files)
1268
self.assertFalse('bar' in obsolete_files)
1269
self.assertEqual(50, len(obsolete_files))
1270
# XXX: Todo check packs obsoleted correctly - old packs and indices
1271
# in the obsolete_packs directory.
1272
large_pack_name = list(index.iter_all_entries())[0][1][0]
1273
# finally, committing again should not touch the large pack.
1274
tree.commit('commit not triggering pack')
1275
index = GraphIndex(trans, 'pack-names', None)
1276
self.assertEqual(2, len(list(index.iter_all_entries())))
1277
pack_names = [node[1][0] for node in index.iter_all_entries()]
1278
self.assertTrue(large_pack_name in pack_names)
1281
class TestDevelopment1(TestKnitPackNoSubtrees, TestExternalDevelopment1):
1283
def get_format(self):
1284
return bzrdir.format_registry.make_bzrdir(
1287
def check_format(self, t):
1288
self.assertEqualDiff(
1289
"Bazaar development format 1 (needs bzr.dev from before 1.6)\n",
1290
t.get('format').read())
1292
def test_supports_external_lookups(self):
1293
repo = self.make_repository('.', format=self.get_format())
1294
self.assertTrue(repo._format.supports_external_lookups)
1297
class TestDevelopment1Subtree(TestKnitPackNoSubtrees, TestExternalDevelopment1):
1299
def get_format(self):
1300
return bzrdir.format_registry.make_bzrdir(
1301
'development-subtree')
1303
def check_format(self, t):
1304
self.assertEqualDiff(
1305
"Bazaar development format 1 with subtree support "
1306
"(needs bzr.dev from before 1.6)\n",
1307
t.get('format').read())
1309
def test_supports_external_lookups(self):
1310
repo = self.make_repository('.', format=self.get_format())
1311
self.assertTrue(repo._format.supports_external_lookups)
1314
class TestRepositoryPackCollection(TestCaseWithTransport):
1316
def get_format(self):
1317
return bzrdir.format_registry.make_bzrdir('pack-0.92')
1319
def test__max_pack_count(self):
1320
"""The maximum pack count is a function of the number of revisions."""
1321
format = self.get_format()
1322
repo = self.make_repository('.', format=format)
1323
packs = repo._pack_collection
1324
# no revisions - one pack, so that we can have a revision free repo
1325
# without it blowing up
1326
self.assertEqual(1, packs._max_pack_count(0))
1327
# after that the sum of the digits, - check the first 1-9
1328
self.assertEqual(1, packs._max_pack_count(1))
1329
self.assertEqual(2, packs._max_pack_count(2))
1330
self.assertEqual(3, packs._max_pack_count(3))
1331
self.assertEqual(4, packs._max_pack_count(4))
1332
self.assertEqual(5, packs._max_pack_count(5))
1333
self.assertEqual(6, packs._max_pack_count(6))
1334
self.assertEqual(7, packs._max_pack_count(7))
1335
self.assertEqual(8, packs._max_pack_count(8))
1336
self.assertEqual(9, packs._max_pack_count(9))
1337
# check the boundary cases with two digits for the next decade
1338
self.assertEqual(1, packs._max_pack_count(10))
1339
self.assertEqual(2, packs._max_pack_count(11))
1340
self.assertEqual(10, packs._max_pack_count(19))
1341
self.assertEqual(2, packs._max_pack_count(20))
1342
self.assertEqual(3, packs._max_pack_count(21))
1343
# check some arbitrary big numbers
1344
self.assertEqual(25, packs._max_pack_count(112894))
1346
def test_pack_distribution_zero(self):
1347
format = self.get_format()
1348
repo = self.make_repository('.', format=format)
1349
packs = repo._pack_collection
1350
self.assertEqual([0], packs.pack_distribution(0))
1352
def test_ensure_loaded_unlocked(self):
1353
format = self.get_format()
1354
repo = self.make_repository('.', format=format)
1355
self.assertRaises(errors.ObjectNotLocked,
1356
repo._pack_collection.ensure_loaded)
1358
def test_pack_distribution_one_to_nine(self):
1359
format = self.get_format()
1360
repo = self.make_repository('.', format=format)
1361
packs = repo._pack_collection
1362
self.assertEqual([1],
1363
packs.pack_distribution(1))
1364
self.assertEqual([1, 1],
1365
packs.pack_distribution(2))
1366
self.assertEqual([1, 1, 1],
1367
packs.pack_distribution(3))
1368
self.assertEqual([1, 1, 1, 1],
1369
packs.pack_distribution(4))
1370
self.assertEqual([1, 1, 1, 1, 1],
1371
packs.pack_distribution(5))
1372
self.assertEqual([1, 1, 1, 1, 1, 1],
1373
packs.pack_distribution(6))
1374
self.assertEqual([1, 1, 1, 1, 1, 1, 1],
1375
packs.pack_distribution(7))
1376
self.assertEqual([1, 1, 1, 1, 1, 1, 1, 1],
1377
packs.pack_distribution(8))
1378
self.assertEqual([1, 1, 1, 1, 1, 1, 1, 1, 1],
1379
packs.pack_distribution(9))
1381
def test_pack_distribution_stable_at_boundaries(self):
1382
"""When there are multi-rev packs the counts are stable."""
1383
format = self.get_format()
1384
repo = self.make_repository('.', format=format)
1385
packs = repo._pack_collection
1387
self.assertEqual([10], packs.pack_distribution(10))
1388
self.assertEqual([10, 1], packs.pack_distribution(11))
1389
self.assertEqual([10, 10], packs.pack_distribution(20))
1390
self.assertEqual([10, 10, 1], packs.pack_distribution(21))
1392
self.assertEqual([100], packs.pack_distribution(100))
1393
self.assertEqual([100, 1], packs.pack_distribution(101))
1394
self.assertEqual([100, 10, 1], packs.pack_distribution(111))
1395
self.assertEqual([100, 100], packs.pack_distribution(200))
1396
self.assertEqual([100, 100, 1], packs.pack_distribution(201))
1397
self.assertEqual([100, 100, 10, 1], packs.pack_distribution(211))
1399
def test_plan_pack_operations_2009_revisions_skip_all_packs(self):
1400
format = self.get_format()
1401
repo = self.make_repository('.', format=format)
1402
packs = repo._pack_collection
1403
existing_packs = [(2000, "big"), (9, "medium")]
1404
# rev count - 2009 -> 2x1000 + 9x1
1405
pack_operations = packs.plan_autopack_combinations(
1406
existing_packs, [1000, 1000, 1, 1, 1, 1, 1, 1, 1, 1, 1])
1407
self.assertEqual([], pack_operations)
1409
def test_plan_pack_operations_2010_revisions_skip_all_packs(self):
1410
format = self.get_format()
1411
repo = self.make_repository('.', format=format)
1412
packs = repo._pack_collection
1413
existing_packs = [(2000, "big"), (9, "medium"), (1, "single")]
1414
# rev count - 2010 -> 2x1000 + 1x10
1415
pack_operations = packs.plan_autopack_combinations(
1416
existing_packs, [1000, 1000, 10])
1417
self.assertEqual([], pack_operations)
1419
def test_plan_pack_operations_2010_combines_smallest_two(self):
1420
format = self.get_format()
1421
repo = self.make_repository('.', format=format)
1422
packs = repo._pack_collection
1423
existing_packs = [(1999, "big"), (9, "medium"), (1, "single2"),
1425
# rev count - 2010 -> 2x1000 + 1x10 (3)
1426
pack_operations = packs.plan_autopack_combinations(
1427
existing_packs, [1000, 1000, 10])
1428
self.assertEqual([[2, ["single2", "single1"]], [0, []]], pack_operations)
1430
def test_all_packs_none(self):
1431
format = self.get_format()
1432
tree = self.make_branch_and_tree('.', format=format)
1434
self.addCleanup(tree.unlock)
1435
packs = tree.branch.repository._pack_collection
1436
packs.ensure_loaded()
1437
self.assertEqual([], packs.all_packs())
1439
def test_all_packs_one(self):
1440
format = self.get_format()
1441
tree = self.make_branch_and_tree('.', format=format)
1442
tree.commit('start')
1444
self.addCleanup(tree.unlock)
1445
packs = tree.branch.repository._pack_collection
1446
packs.ensure_loaded()
1448
packs.get_pack_by_name(packs.names()[0])],
1451
def test_all_packs_two(self):
1452
format = self.get_format()
1453
tree = self.make_branch_and_tree('.', format=format)
1454
tree.commit('start')
1455
tree.commit('continue')
1457
self.addCleanup(tree.unlock)
1458
packs = tree.branch.repository._pack_collection
1459
packs.ensure_loaded()
1461
packs.get_pack_by_name(packs.names()[0]),
1462
packs.get_pack_by_name(packs.names()[1]),
1463
], packs.all_packs())
1465
def test_get_pack_by_name(self):
1466
format = self.get_format()
1467
tree = self.make_branch_and_tree('.', format=format)
1468
tree.commit('start')
1470
self.addCleanup(tree.unlock)
1471
packs = tree.branch.repository._pack_collection
1472
packs.ensure_loaded()
1473
name = packs.names()[0]
1474
pack_1 = packs.get_pack_by_name(name)
1475
# the pack should be correctly initialised
1476
sizes = packs._names[name]
1477
rev_index = GraphIndex(packs._index_transport, name + '.rix', sizes[0])
1478
inv_index = GraphIndex(packs._index_transport, name + '.iix', sizes[1])
1479
txt_index = GraphIndex(packs._index_transport, name + '.tix', sizes[2])
1480
sig_index = GraphIndex(packs._index_transport, name + '.six', sizes[3])
1481
self.assertEqual(pack_repo.ExistingPack(packs._pack_transport,
1482
name, rev_index, inv_index, txt_index, sig_index), pack_1)
1483
# and the same instance should be returned on successive calls.
1484
self.assertTrue(pack_1 is packs.get_pack_by_name(name))
1487
class TestPack(TestCaseWithTransport):
1488
"""Tests for the Pack object."""
1490
def assertCurrentlyEqual(self, left, right):
1491
self.assertTrue(left == right)
1492
self.assertTrue(right == left)
1493
self.assertFalse(left != right)
1494
self.assertFalse(right != left)
1496
def assertCurrentlyNotEqual(self, left, right):
1497
self.assertFalse(left == right)
1498
self.assertFalse(right == left)
1499
self.assertTrue(left != right)
1500
self.assertTrue(right != left)
1502
def test___eq____ne__(self):
1503
left = pack_repo.ExistingPack('', '', '', '', '', '')
1504
right = pack_repo.ExistingPack('', '', '', '', '', '')
1505
self.assertCurrentlyEqual(left, right)
1506
# change all attributes and ensure equality changes as we do.
1507
left.revision_index = 'a'
1508
self.assertCurrentlyNotEqual(left, right)
1509
right.revision_index = 'a'
1510
self.assertCurrentlyEqual(left, right)
1511
left.inventory_index = 'a'
1512
self.assertCurrentlyNotEqual(left, right)
1513
right.inventory_index = 'a'
1514
self.assertCurrentlyEqual(left, right)
1515
left.text_index = 'a'
1516
self.assertCurrentlyNotEqual(left, right)
1517
right.text_index = 'a'
1518
self.assertCurrentlyEqual(left, right)
1519
left.signature_index = 'a'
1520
self.assertCurrentlyNotEqual(left, right)
1521
right.signature_index = 'a'
1522
self.assertCurrentlyEqual(left, right)
1524
self.assertCurrentlyNotEqual(left, right)
1526
self.assertCurrentlyEqual(left, right)
1527
left.transport = 'a'
1528
self.assertCurrentlyNotEqual(left, right)
1529
right.transport = 'a'
1530
self.assertCurrentlyEqual(left, right)
1532
def test_file_name(self):
1533
pack = pack_repo.ExistingPack('', 'a_name', '', '', '', '')
1534
self.assertEqual('a_name.pack', pack.file_name())
1537
class TestNewPack(TestCaseWithTransport):
1538
"""Tests for pack_repo.NewPack."""
1540
def test_new_instance_attributes(self):
1541
upload_transport = self.get_transport('upload')
1542
pack_transport = self.get_transport('pack')
1543
index_transport = self.get_transport('index')
1544
upload_transport.mkdir('.')
1545
pack = pack_repo.NewPack(upload_transport, index_transport,
1547
self.assertIsInstance(pack.revision_index, InMemoryGraphIndex)
1548
self.assertIsInstance(pack.inventory_index, InMemoryGraphIndex)
1549
self.assertIsInstance(pack._hash, type(md5.new()))
1550
self.assertTrue(pack.upload_transport is upload_transport)
1551
self.assertTrue(pack.index_transport is index_transport)
1552
self.assertTrue(pack.pack_transport is pack_transport)
1553
self.assertEqual(None, pack.index_sizes)
1554
self.assertEqual(20, len(pack.random_name))
1555
self.assertIsInstance(pack.random_name, str)
1556
self.assertIsInstance(pack.start_time, float)
1559
class TestPacker(TestCaseWithTransport):
1560
"""Tests for the packs repository Packer class."""
1562
# To date, this class has been factored out and nothing new added to it;
1563
# thus there are not yet any tests.
1566
class TestInterDifferingSerializer(TestCaseWithTransport):
1568
def test_progress_bar(self):
1569
tree = self.make_branch_and_tree('tree')
1570
tree.commit('rev1', rev_id='rev-1')
1571
tree.commit('rev2', rev_id='rev-2')
1572
tree.commit('rev3', rev_id='rev-3')
1573
repo = self.make_repository('repo')
1574
inter_repo = repository.InterDifferingSerializer(
1575
tree.branch.repository, repo)
1576
pb = progress.InstrumentedProgress(to_file=StringIO())
1577
pb.never_throttle = True
1578
inter_repo.fetch('rev-1', pb)
1579
self.assertEqual('Transferring revisions', pb.last_msg)
1580
self.assertEqual(1, pb.last_cnt)
1581
self.assertEqual(1, pb.last_total)
1582
inter_repo.fetch('rev-3', pb)
1583
self.assertEqual(2, pb.last_cnt)
1584
self.assertEqual(2, pb.last_total)
added
removed
bzrlib/tests/test_repository.py
