← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_repository.py

  • Committer: Vincent Ladeuil
  • Date: 2009-06-22 12:52:39 UTC
  • mto: (4471.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4472.
  • Revision ID: v.ladeuil+lp@free.fr-20090622125239-kabo9smxt9c3vnir
Use a consistent scheme for naming pyrex source files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_repository.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the Repository facility that are not interface tests.
18
18
 
19
 
For interface tests see tests/repository_implementations/*.py.
 
19
For interface tests see tests/per_repository/*.py.
20
20
 
21
21
For concrete class tests see this file, and for storage formats tests
22
22
also see this file.
23
23
"""
24
24
 
25
 
import md5
26
25
from stat import S_ISDIR
27
26
from StringIO import StringIO
28
27
 
33
32
                           UnsupportedFormatError,
34
33
                           )
35
34
from bzrlib import graph
 
35
from bzrlib.branchbuilder import BranchBuilder
 
36
from bzrlib.btree_index import BTreeBuilder, BTreeGraphIndex
36
37
from bzrlib.index import GraphIndex, InMemoryGraphIndex
37
38
from bzrlib.repository import RepositoryFormat
38
39
from bzrlib.smart import server
39
40
from bzrlib.tests import (
40
41
    TestCase,
41
42
    TestCaseWithTransport,
 
43
    TestSkipped,
42
44
    test_knit,
43
45
    )
44
 
from bzrlib.transport import get_transport
 
46
from bzrlib.transport import (
 
47
    fakenfs,
 
48
    get_transport,
 
49
    )
45
50
from bzrlib.transport.memory import MemoryServer
46
 
from bzrlib.util import bencode
47
51
from bzrlib import (
 
52
    bencode,
48
53
    bzrdir,
49
54
    errors,
50
55
    inventory,
 
56
    osutils,
51
57
    progress,
52
58
    repository,
53
59
    revision as _mod_revision,
55
61
    upgrade,
56
62
    workingtree,
57
63
    )
58
 
from bzrlib.repofmt import knitrepo, weaverepo, pack_repo
 
64
from bzrlib.repofmt import (
 
65
    groupcompress_repo,
 
66
    knitrepo,
 
67
    pack_repo,
 
68
    weaverepo,
 
69
    )
59
70
 
60
71
 
61
72
class TestDefaultFormat(TestCase):
90
101
class SampleRepositoryFormat(repository.RepositoryFormat):
91
102
    """A sample format
92
103
 
93
 
    this format is initializable, unsupported to aid in testing the 
 
104
    this format is initializable, unsupported to aid in testing the
94
105
    open and open(unsupported=True) routines.
95
106
    """
96
107
 
117
128
    def test_find_format(self):
118
129
        # is the right format object found for a repository?
119
130
        # create a branch with a few known format objects.
120
 
        # this is not quite the same as 
 
131
        # this is not quite the same as
121
132
        self.build_tree(["foo/", "bar/"])
122
133
        def check_format(format, url):
123
134
            dir = format._matchingbzrdir.initialize(url)
126
137
            found_format = repository.RepositoryFormat.find_format(dir)
127
138
            self.failUnless(isinstance(found_format, format.__class__))
128
139
        check_format(weaverepo.RepositoryFormat7(), "bar")
129
 
        
 
140
 
130
141
    def test_find_format_no_repository(self):
131
142
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
132
143
        self.assertRaises(errors.NoRepositoryPresent,
158
169
 
159
170
class TestFormat6(TestCaseWithTransport):
160
171
 
 
172
    def test_attribute__fetch_order(self):
 
173
        """Weaves need topological data insertion."""
 
174
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
 
175
        repo = weaverepo.RepositoryFormat6().initialize(control)
 
176
        self.assertEqual('topological', repo._format._fetch_order)
 
177
 
 
178
    def test_attribute__fetch_uses_deltas(self):
 
179
        """Weaves do not reuse deltas."""
 
180
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
 
181
        repo = weaverepo.RepositoryFormat6().initialize(control)
 
182
        self.assertEqual(False, repo._format._fetch_uses_deltas)
 
183
 
 
184
    def test_attribute__fetch_reconcile(self):
 
185
        """Weave repositories need a reconcile after fetch."""
 
186
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
 
187
        repo = weaverepo.RepositoryFormat6().initialize(control)
 
188
        self.assertEqual(True, repo._format._fetch_reconcile)
 
189
 
161
190
    def test_no_ancestry_weave(self):
162
191
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
163
192
        repo = weaverepo.RepositoryFormat6().initialize(control)
167
196
                          control.transport.get,
168
197
                          'ancestry.weave')
169
198
 
170
 
    def test_exposed_versioned_files_are_marked_dirty(self):
171
 
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
172
 
        repo = weaverepo.RepositoryFormat6().initialize(control)
173
 
        repo.lock_write()
174
 
        inv = repo.get_inventory_weave()
175
 
        repo.unlock()
176
 
        self.assertRaises(errors.OutSideTransaction,
177
 
            inv.add_lines, 'foo', [], [])
178
 
 
179
199
    def test_supports_external_lookups(self):
180
200
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
181
201
        repo = weaverepo.RepositoryFormat6().initialize(control)
183
203
 
184
204
 
185
205
class TestFormat7(TestCaseWithTransport):
186
 
    
 
206
 
 
207
    def test_attribute__fetch_order(self):
 
208
        """Weaves need topological data insertion."""
 
209
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
210
        repo = weaverepo.RepositoryFormat7().initialize(control)
 
211
        self.assertEqual('topological', repo._format._fetch_order)
 
212
 
 
213
    def test_attribute__fetch_uses_deltas(self):
 
214
        """Weaves do not reuse deltas."""
 
215
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
216
        repo = weaverepo.RepositoryFormat7().initialize(control)
 
217
        self.assertEqual(False, repo._format._fetch_uses_deltas)
 
218
 
 
219
    def test_attribute__fetch_reconcile(self):
 
220
        """Weave repositories need a reconcile after fetch."""
 
221
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
222
        repo = weaverepo.RepositoryFormat7().initialize(control)
 
223
        self.assertEqual(True, repo._format._fetch_reconcile)
 
224
 
187
225
    def test_disk_layout(self):
188
226
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
189
227
        repo = weaverepo.RepositoryFormat7().initialize(control)
205
243
                             'w\n'
206
244
                             'W\n',
207
245
                             t.get('inventory.weave').read())
 
246
        # Creating a file with id Foo:Bar results in a non-escaped file name on
 
247
        # disk.
 
248
        control.create_branch()
 
249
        tree = control.create_workingtree()
 
250
        tree.add(['foo'], ['Foo:Bar'], ['file'])
 
251
        tree.put_file_bytes_non_atomic('Foo:Bar', 'content\n')
 
252
        tree.commit('first post', rev_id='first')
 
253
        self.assertEqualDiff(
 
254
            '# bzr weave file v5\n'
 
255
            'i\n'
 
256
            '1 7fe70820e08a1aac0ef224d9c66ab66831cc4ab1\n'
 
257
            'n first\n'
 
258
            '\n'
 
259
            'w\n'
 
260
            '{ 0\n'
 
261
            '. content\n'
 
262
            '}\n'
 
263
            'W\n',
 
264
            t.get('weaves/74/Foo%3ABar.weave').read())
208
265
 
209
266
    def test_shared_disk_layout(self):
210
267
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
233
290
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
234
291
        repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
235
292
        t = control.get_repository_transport(None)
236
 
        # TODO: Should check there is a 'lock' toplevel directory, 
 
293
        # TODO: Should check there is a 'lock' toplevel directory,
237
294
        # regardless of contents
238
295
        self.assertFalse(t.has('lock/held/info'))
239
296
        repo.lock_write()
285
342
                             'W\n',
286
343
                             t.get('inventory.weave').read())
287
344
 
288
 
    def test_exposed_versioned_files_are_marked_dirty(self):
289
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
290
 
        repo = weaverepo.RepositoryFormat7().initialize(control)
291
 
        repo.lock_write()
292
 
        inv = repo.get_inventory_weave()
293
 
        repo.unlock()
294
 
        self.assertRaises(errors.OutSideTransaction,
295
 
            inv.add_lines, 'foo', [], [])
296
 
 
297
345
    def test_supports_external_lookups(self):
298
346
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
299
347
        repo = weaverepo.RepositoryFormat7().initialize(control)
301
349
 
302
350
 
303
351
class TestFormatKnit1(TestCaseWithTransport):
304
 
    
 
352
 
 
353
    def test_attribute__fetch_order(self):
 
354
        """Knits need topological data insertion."""
 
355
        repo = self.make_repository('.',
 
356
                format=bzrdir.format_registry.get('knit')())
 
357
        self.assertEqual('topological', repo._format._fetch_order)
 
358
 
 
359
    def test_attribute__fetch_uses_deltas(self):
 
360
        """Knits reuse deltas."""
 
361
        repo = self.make_repository('.',
 
362
                format=bzrdir.format_registry.get('knit')())
 
363
        self.assertEqual(True, repo._format._fetch_uses_deltas)
 
364
 
305
365
    def test_disk_layout(self):
306
366
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
307
367
        repo = knitrepo.RepositoryFormatKnit1().initialize(control)
321
381
        # self.assertEqualDiff('', t.get('lock').read())
322
382
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
323
383
        self.check_knits(t)
 
384
        # Check per-file knits.
 
385
        branch = control.create_branch()
 
386
        tree = control.create_workingtree()
 
387
        tree.add(['foo'], ['Nasty-IdC:'], ['file'])
 
388
        tree.put_file_bytes_non_atomic('Nasty-IdC:', '')
 
389
        tree.commit('1st post', rev_id='foo')
 
390
        self.assertHasKnit(t, 'knits/e8/%254easty-%2549d%2543%253a',
 
391
            '\nfoo fulltext 0 81  :')
324
392
 
325
 
    def assertHasKnit(self, t, knit_name):
 
393
    def assertHasKnit(self, t, knit_name, extra_content=''):
326
394
        """Assert that knit_name exists on t."""
327
 
        self.assertEqualDiff('# bzr knit index 8\n',
 
395
        self.assertEqualDiff('# bzr knit index 8\n' + extra_content,
328
396
                             t.get(knit_name + '.kndx').read())
329
 
        # no default content
330
 
        self.assertTrue(t.has(knit_name + '.knit'))
331
397
 
332
398
    def check_knits(self, t):
333
399
        """check knit content for a repository."""
377
443
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
378
444
        self.check_knits(t)
379
445
 
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)
384
 
        repo.lock_write()
385
 
        inv = repo.get_inventory_weave()
386
 
        repo.unlock()
387
 
        self.assertRaises(errors.OutSideTransaction,
388
 
            inv.add_lines, 'foo', [], [])
389
 
 
390
446
    def test_deserialise_sets_root_revision(self):
391
447
        """We must have a inventory.root.revision
392
448
 
420
476
        self.assertFalse(repo._format.supports_external_lookups)
421
477
 
422
478
 
423
 
class KnitRepositoryStreamTests(test_knit.KnitTests):
424
 
    """Tests for knitrepo._get_stream_as_bytes."""
425
 
 
426
 
    def test_get_stream_as_bytes(self):
427
 
        # Make a simple knit
428
 
        k1 = self.make_test_knit()
429
 
        k1.add_lines('text-a', [], test_knit.split_lines(test_knit.TEXT_1))
430
 
        
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])
438
 
 
439
 
    def test_get_stream_as_bytes_all(self):
440
 
        """Get a serialised data stream for all the records in a knit.
441
 
 
442
 
        Much like test_get_stream_all, except for get_stream_as_bytes.
443
 
        """
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).
447
 
        test_data = [
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),
453
 
           ]
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)
456
 
        # behaviour.
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']),
464
 
            ]
465
 
        for version_id, parents, lines in test_data:
466
 
            k1.add_lines(version_id, parents, test_knit.split_lines(lines))
467
 
 
468
 
        bytes = knitrepo._get_stream_as_bytes(
469
 
            k1, ['text-a', 'text-b', 'text-m', 'text-c', 'text-d', ])
470
 
 
471
 
        data = bencode.bdecode(bytes)
472
 
        format = data.pop(0)
473
 
        self.assertEqual('knit-plain', format)
474
 
 
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)
484
 
 
485
 
 
486
479
class DummyRepository(object):
487
480
    """A dummy repository for testing."""
488
481
 
 
482
    _format = None
489
483
    _serializer = None
490
484
 
491
485
    def supports_rich_root(self):
492
486
        return False
493
487
 
 
488
    def get_graph(self):
 
489
        raise NotImplementedError
 
490
 
 
491
    def get_parent_map(self, revision_ids):
 
492
        raise NotImplementedError
 
493
 
494
494
 
495
495
class InterDummy(repository.InterRepository):
496
496
    """An inter-repository optimised code path for DummyRepository.
503
503
    @staticmethod
504
504
    def is_compatible(repo_source, repo_target):
505
505
        """InterDummy is compatible with DummyRepository."""
506
 
        return (isinstance(repo_source, DummyRepository) and 
 
506
        return (isinstance(repo_source, DummyRepository) and
507
507
            isinstance(repo_target, DummyRepository))
508
508
 
509
509
 
522
522
 
523
523
    def assertGetsDefaultInterRepository(self, repo_a, repo_b):
524
524
        """Asserts that InterRepository.get(repo_a, repo_b) -> the default.
525
 
        
 
525
 
526
526
        The effective default is now InterSameDataRepository because there is
527
527
        no actual sane default in the presence of incompatible data models.
528
528
        """
593
593
                                                        repo_b).__class__)
594
594
 
595
595
 
596
 
class TestInterRemoteToOther(TestCaseWithTransport):
597
 
 
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()
603
 
        smart_server.setUp()
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()
608
 
        return remote_repo
609
 
 
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
616
 
        self.assertTrue(
617
 
            is_compatible(remote_repo, local_repo),
618
 
            "InterRemoteToOther(%r, %r) is false" % (remote_repo, local_repo))
619
 
          
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
624
 
        self.assertFalse(
625
 
            is_compatible(remote_repo, local_repo),
626
 
            "InterRemoteToOther(%r, %r) is true" % (local_repo, remote_repo))
627
 
 
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
633
 
        self.assertFalse(
634
 
            is_compatible(remote_repo_a, remote_repo_b),
635
 
            "InterRemoteToOther(%r, %r) is true"
636
 
            % (remote_repo_a, remote_repo_b))
637
 
 
638
 
 
639
596
class TestRepositoryConverter(TestCaseWithTransport):
640
597
 
641
598
    def test_convert_empty(self):
655
612
 
656
613
 
657
614
class TestMisc(TestCase):
658
 
    
 
615
 
659
616
    def test_unescape_xml(self):
660
617
        """We get some kind of error when malformed entities are passed"""
661
 
        self.assertRaises(KeyError, repository._unescape_xml, 'foo&bar;') 
 
618
        self.assertRaises(KeyError, repository._unescape_xml, 'foo&bar;')
662
619
 
663
620
 
664
621
class TestRepositoryFormatKnit3(TestCaseWithTransport):
665
622
 
 
623
    def test_attribute__fetch_order(self):
 
624
        """Knits need topological data insertion."""
 
625
        format = bzrdir.BzrDirMetaFormat1()
 
626
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
627
        repo = self.make_repository('.', format=format)
 
628
        self.assertEqual('topological', repo._format._fetch_order)
 
629
 
 
630
    def test_attribute__fetch_uses_deltas(self):
 
631
        """Knits reuse deltas."""
 
632
        format = bzrdir.BzrDirMetaFormat1()
 
633
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
634
        repo = self.make_repository('.', format=format)
 
635
        self.assertEqual(True, repo._format._fetch_uses_deltas)
 
636
 
666
637
    def test_convert(self):
667
638
        """Ensure the upgrade adds weaves for roots"""
668
639
        format = bzrdir.BzrDirMetaFormat1()
670
641
        tree = self.make_branch_and_tree('.', format)
671
642
        tree.commit("Dull commit", rev_id="dull")
672
643
        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)
 
644
        revision_tree.lock_read()
 
645
        try:
 
646
            self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
 
647
                revision_tree.inventory.root.file_id)
 
648
        finally:
 
649
            revision_tree.unlock()
675
650
        format = bzrdir.BzrDirMetaFormat1()
676
651
        format.repository_format = knitrepo.RepositoryFormatKnit3()
677
652
        upgrade.Convert('.', format)
678
653
        tree = workingtree.WorkingTree.open('.')
679
654
        revision_tree = tree.branch.repository.revision_tree('dull')
680
 
        revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
 
655
        revision_tree.lock_read()
 
656
        try:
 
657
            revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
 
658
        finally:
 
659
            revision_tree.unlock()
681
660
        tree.commit("Another dull commit", rev_id='dull2')
682
661
        revision_tree = tree.branch.repository.revision_tree('dull2')
 
662
        revision_tree.lock_read()
 
663
        self.addCleanup(revision_tree.unlock)
683
664
        self.assertEqual('dull', revision_tree.inventory.root.revision)
684
665
 
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)
689
 
        repo.lock_write()
690
 
        inv = repo.get_inventory_weave()
691
 
        repo.unlock()
692
 
        self.assertRaises(errors.OutSideTransaction,
693
 
            inv.add_lines, 'foo', [], [])
694
 
 
695
666
    def test_supports_external_lookups(self):
696
667
        format = bzrdir.BzrDirMetaFormat1()
697
668
        format.repository_format = knitrepo.RepositoryFormatKnit3()
699
670
        self.assertFalse(repo._format.supports_external_lookups)
700
671
 
701
672
 
 
673
class TestDevelopment6(TestCaseWithTransport):
 
674
 
 
675
    def test_inventories_use_chk_map_with_parent_base_dict(self):
 
676
        tree = self.make_branch_and_tree('repo', format="development6-rich-root")
 
677
        revid = tree.commit("foo")
 
678
        tree.lock_read()
 
679
        self.addCleanup(tree.unlock)
 
680
        inv = tree.branch.repository.get_inventory(revid)
 
681
        self.assertNotEqual(None, inv.parent_id_basename_to_file_id)
 
682
        inv.parent_id_basename_to_file_id._ensure_root()
 
683
        inv.id_to_entry._ensure_root()
 
684
        self.assertEqual(65536, inv.id_to_entry._root_node.maximum_size)
 
685
        self.assertEqual(65536,
 
686
            inv.parent_id_basename_to_file_id._root_node.maximum_size)
 
687
 
 
688
 
 
689
class TestDevelopment6FindParentIdsOfRevisions(TestCaseWithTransport):
 
690
    """Tests for _find_parent_ids_of_revisions."""
 
691
 
 
692
    def setUp(self):
 
693
        super(TestDevelopment6FindParentIdsOfRevisions, self).setUp()
 
694
        self.builder = self.make_branch_builder('source',
 
695
            format='development6-rich-root')
 
696
        self.builder.start_series()
 
697
        self.builder.build_snapshot('initial', None,
 
698
            [('add', ('', 'tree-root', 'directory', None))])
 
699
        self.repo = self.builder.get_branch().repository
 
700
        self.addCleanup(self.builder.finish_series)
 
701
 
 
702
    def assertParentIds(self, expected_result, rev_set):
 
703
        self.assertEqual(sorted(expected_result),
 
704
            sorted(self.repo._find_parent_ids_of_revisions(rev_set)))
 
705
 
 
706
    def test_simple(self):
 
707
        self.builder.build_snapshot('revid1', None, [])
 
708
        self.builder.build_snapshot('revid2', ['revid1'], [])
 
709
        rev_set = ['revid2']
 
710
        self.assertParentIds(['revid1'], rev_set)
 
711
 
 
712
    def test_not_first_parent(self):
 
713
        self.builder.build_snapshot('revid1', None, [])
 
714
        self.builder.build_snapshot('revid2', ['revid1'], [])
 
715
        self.builder.build_snapshot('revid3', ['revid2'], [])
 
716
        rev_set = ['revid3', 'revid2']
 
717
        self.assertParentIds(['revid1'], rev_set)
 
718
 
 
719
    def test_not_null(self):
 
720
        rev_set = ['initial']
 
721
        self.assertParentIds([], rev_set)
 
722
 
 
723
    def test_not_null_set(self):
 
724
        self.builder.build_snapshot('revid1', None, [])
 
725
        rev_set = [_mod_revision.NULL_REVISION]
 
726
        self.assertParentIds([], rev_set)
 
727
 
 
728
    def test_ghost(self):
 
729
        self.builder.build_snapshot('revid1', None, [])
 
730
        rev_set = ['ghost', 'revid1']
 
731
        self.assertParentIds(['initial'], rev_set)
 
732
 
 
733
    def test_ghost_parent(self):
 
734
        self.builder.build_snapshot('revid1', None, [])
 
735
        self.builder.build_snapshot('revid2', ['revid1', 'ghost'], [])
 
736
        rev_set = ['revid2', 'revid1']
 
737
        self.assertParentIds(['ghost', 'initial'], rev_set)
 
738
 
 
739
    def test_righthand_parent(self):
 
740
        self.builder.build_snapshot('revid1', None, [])
 
741
        self.builder.build_snapshot('revid2a', ['revid1'], [])
 
742
        self.builder.build_snapshot('revid2b', ['revid1'], [])
 
743
        self.builder.build_snapshot('revid3', ['revid2a', 'revid2b'], [])
 
744
        rev_set = ['revid3', 'revid2a']
 
745
        self.assertParentIds(['revid1', 'revid2b'], rev_set)
 
746
 
 
747
 
702
748
class TestWithBrokenRepo(TestCaseWithTransport):
703
749
    """These tests seem to be more appropriate as interface tests?"""
704
750
 
769
815
        entry.revision = revision
770
816
        entry.text_size = 0
771
817
        inv.add(entry)
772
 
        vf = repo.weave_store.get_weave_or_empty(file_id,
773
 
                                                 repo.get_transaction())
774
 
        vf.add_lines(revision, parents, ['line\n'])
 
818
        text_key = (file_id, revision)
 
819
        parent_keys = [(file_id, parent) for parent in parents]
 
820
        repo.texts.add_lines(text_key, parent_keys, ['line\n'])
775
821
 
776
822
    def test_insert_from_broken_repo(self):
777
823
        """Inserting a data stream from a broken repository won't silently
779
825
        """
780
826
        broken_repo = self.make_broken_repository()
781
827
        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()
790
 
        try:
791
 
            self.assertRaises(
792
 
                errors.KnitCorrupt, empty_repo.insert_data_stream, stream)
793
 
        finally:
794
 
            empty_repo.abort_write_group()
795
 
 
796
 
 
797
 
class TestKnitPackNoSubtrees(TestCaseWithTransport):
798
 
 
799
 
    def get_format(self):
800
 
        return bzrdir.format_registry.make_bzrdir('pack-0.92')
801
 
 
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.
806
 
        repo.lock_write()
807
 
        repo.unlock()
808
 
        t = repo.bzrdir.get_repository_transport(None)
809
 
        self.check_format(t)
810
 
        # XXX: no locks left when unlocked at the moment
811
 
        # self.assertEqualDiff('', t.get('lock').read())
812
 
        self.check_databases(t)
813
 
 
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())
818
 
 
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())
823
 
 
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'))
827
 
 
828
 
    def assertHasNoKnit(self, t, knit_name):
829
 
        """Assert that knit_name exists on t."""
830
 
        # no default content
831
 
        self.assertFalse(t.has(knit_name + '.knit'))
832
 
 
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
844
 
        self.assertEqual([],
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))
850
 
 
851
 
    def test_shared_disk_layout(self):
852
 
        format = self.get_format()
853
 
        repo = self.make_repository('.', shared=True, format=format)
854
 
        # we want:
855
 
        t = repo.bzrdir.get_repository_transport(None)
856
 
        self.check_format(t)
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)
862
 
 
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)
867
 
        # we want:
868
 
        t = repo.bzrdir.get_repository_transport(None)
869
 
        self.check_format(t)
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)
880
 
 
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)
885
 
        self.assertEqual([],
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]
892
 
        name = node[1][0]
893
 
        # the pack sizes should be listed in the index
894
 
        pack_value = node[2]
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)
899
 
 
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)
906
 
        self.assertEqual([],
907
 
            list(GraphIndex(trans, 'pack-names', None).iter_all_entries()))
908
 
 
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
917
 
        # test.
918
 
        for x in range(9):
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)
948
 
 
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)
953
 
        tree.commit('start')
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()))
960
 
 
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()
968
 
        tree.lock_read()
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():
975
 
            if key == ('1',):
976
 
                pos_1 = int(val[1:].split()[0])
977
 
            else:
978
 
                pos_2 = int(val[1:].split()[0])
979
 
        self.assertTrue(pos_2 < pos_1)
980
 
 
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('.')
986
 
        r1.lock_write()
987
 
        self.addCleanup(r1.unlock)
988
 
        r2.lock_write()
989
 
        r2.unlock()
990
 
 
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, [], [])
995
 
 
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('.')
1001
 
        r1.lock_write()
1002
 
        try:
1003
 
            # access enough data to load the names list
1004
 
            list(r1.all_revision_ids())
1005
 
            r2.lock_write()
1006
 
            try:
1007
 
                # access enough data to load the names list
1008
 
                list(r2.all_revision_ids())
1009
 
                r1.start_write_group()
1010
 
                try:
1011
 
                    r2.start_write_group()
1012
 
                    try:
1013
 
                        self._add_text(r1, 'fileidr1')
1014
 
                        self._add_text(r2, 'fileidr2')
1015
 
                    except:
1016
 
                        r2.abort_write_group()
1017
 
                        raise
1018
 
                except:
1019
 
                    r1.abort_write_group()
1020
 
                    raise
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.
1024
 
                try:
1025
 
                    r1.commit_write_group()
1026
 
                except:
1027
 
                    r1.abort_write_group()
1028
 
                    r2.abort_write_group()
1029
 
                    raise
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()))
1038
 
            finally:
1039
 
                r2.unlock()
1040
 
        finally:
1041
 
            r1.unlock()
1042
 
 
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
1049
 
        r1.lock_write()
1050
 
        try:
1051
 
            r1.start_write_group()
1052
 
            try:
1053
 
                self._add_text(r1, 'fileidr1')
1054
 
            except:
1055
 
                r1.abort_write_group()
1056
 
                raise
1057
 
            else:
1058
 
                r1.commit_write_group()
1059
 
            r1._pack_collection.ensure_loaded()
1060
 
            name_to_drop = r1._pack_collection.all_packs()[0].name
1061
 
        finally:
1062
 
            r1.unlock()
1063
 
        r1.lock_write()
1064
 
        try:
1065
 
            # access enough data to load the names list
1066
 
            list(r1.all_revision_ids())
1067
 
            r2.lock_write()
1068
 
            try:
1069
 
                # access enough data to load the names list
1070
 
                list(r2.all_revision_ids())
1071
 
                r1._pack_collection.ensure_loaded()
1072
 
                try:
1073
 
                    r2.start_write_group()
1074
 
                    try:
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))
1078
 
                        # in r2, add a pack
1079
 
                        self._add_text(r2, 'fileidr2')
1080
 
                    except:
1081
 
                        r2.abort_write_group()
1082
 
                        raise
1083
 
                except:
1084
 
                    r1._pack_collection.reset()
1085
 
                    raise
1086
 
                # r1 has a changed names list, and r2 an open write groups with
1087
 
                # changes.
1088
 
                # save r1, and then commit the r2 write group, which requires a
1089
 
                # merge to the pack-names, which should not reinstate
1090
 
                # name_to_drop
1091
 
                try:
1092
 
                    r1._pack_collection._save_pack_names()
1093
 
                    r1._pack_collection.reset()
1094
 
                except:
1095
 
                    r2.abort_write_group()
1096
 
                    raise
1097
 
                try:
1098
 
                    r2.commit_write_group()
1099
 
                except:
1100
 
                    r2.abort_write_group()
1101
 
                    raise
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())
1108
 
            finally:
1109
 
                r2.unlock()
1110
 
        finally:
1111
 
            r1.unlock()
1112
 
 
1113
 
    def test_lock_write_does_not_physically_lock(self):
1114
 
        repo = self.make_repository('.', format=self.get_format())
1115
 
        repo.lock_write()
1116
 
        self.addCleanup(repo.unlock)
1117
 
        self.assertFalse(repo.get_physical_lock_status())
1118
 
 
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")
1128
 
 
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()
1135
 
        repo2.break_lock()
1136
 
        self.assertFalse(repo.get_physical_lock_status())
1137
 
 
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()
1144
 
        repo2.break_lock()
1145
 
        self.assertRaises(errors.LockBroken, repo._pack_collection._unlock_names)
1146
 
 
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
1150
 
        # repository.
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
 
        #------------------------------
1156
 
        # 'ghost'             -
1157
 
        # 'references'    'references'
1158
 
        # 'tip'               -
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())
1163
 
 
1164
 
        def add_commit(repo, revision_id, parent_ids):
1165
 
            repo.lock_write()
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,
1175
 
                                           timezone=None,
1176
 
                                           committer="Foo Bar <foo@example.com>",
1177
 
                                           message="Message",
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()
1183
 
            repo.unlock()
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')
1196
 
 
1197
 
    def test_supports_external_lookups(self):
1198
 
        repo = self.make_repository('.', format=self.get_format())
1199
 
        self.assertFalse(repo._format.supports_external_lookups)
1200
 
 
1201
 
 
1202
 
class TestKnitPackSubtrees(TestKnitPackNoSubtrees):
1203
 
 
1204
 
    def get_format(self):
1205
 
        return bzrdir.format_registry.make_bzrdir(
1206
 
            'pack-0.92-subtree')
1207
 
 
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())
1212
 
 
1213
 
 
1214
 
class TestDevelopment0(TestKnitPackNoSubtrees):
1215
 
 
1216
 
    def get_format(self):
1217
 
        return bzrdir.format_registry.make_bzrdir(
1218
 
            'development')
1219
 
 
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())
1224
 
 
1225
 
 
1226
 
class TestDevelopment0Subtree(TestKnitPackNoSubtrees):
1227
 
 
1228
 
    def get_format(self):
1229
 
        return bzrdir.format_registry.make_bzrdir(
1230
 
            'development-subtree')
1231
 
 
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())
 
828
        self.assertRaises((errors.RevisionNotPresent, errors.BzrCheckError),
 
829
                          empty_repo.fetch, broken_repo)
1237
830
 
1238
831
 
1239
832
class TestRepositoryPackCollection(TestCaseWithTransport):
1241
834
    def get_format(self):
1242
835
        return bzrdir.format_registry.make_bzrdir('pack-0.92')
1243
836
 
 
837
    def get_packs(self):
 
838
        format = self.get_format()
 
839
        repo = self.make_repository('.', format=format)
 
840
        return repo._pack_collection
 
841
 
 
842
    def make_packs_and_alt_repo(self, write_lock=False):
 
843
        """Create a pack repo with 3 packs, and access it via a second repo."""
 
844
        tree = self.make_branch_and_tree('.')
 
845
        tree.lock_write()
 
846
        self.addCleanup(tree.unlock)
 
847
        rev1 = tree.commit('one')
 
848
        rev2 = tree.commit('two')
 
849
        rev3 = tree.commit('three')
 
850
        r = repository.Repository.open('.')
 
851
        if write_lock:
 
852
            r.lock_write()
 
853
        else:
 
854
            r.lock_read()
 
855
        self.addCleanup(r.unlock)
 
856
        packs = r._pack_collection
 
857
        packs.ensure_loaded()
 
858
        return tree, r, packs, [rev1, rev2, rev3]
 
859
 
1244
860
    def test__max_pack_count(self):
1245
861
        """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
862
        # no revisions - one pack, so that we can have a revision free repo
1250
863
        # without it blowing up
 
864
        packs = self.get_packs()
1251
865
        self.assertEqual(1, packs._max_pack_count(0))
1252
866
        # after that the sum of the digits, - check the first 1-9
1253
867
        self.assertEqual(1, packs._max_pack_count(1))
1269
883
        self.assertEqual(25, packs._max_pack_count(112894))
1270
884
 
1271
885
    def test_pack_distribution_zero(self):
1272
 
        format = self.get_format()
1273
 
        repo = self.make_repository('.', format=format)
1274
 
        packs = repo._pack_collection
 
886
        packs = self.get_packs()
1275
887
        self.assertEqual([0], packs.pack_distribution(0))
1276
888
 
1277
889
    def test_ensure_loaded_unlocked(self):
1278
 
        format = self.get_format()
1279
 
        repo = self.make_repository('.', format=format)
 
890
        packs = self.get_packs()
1280
891
        self.assertRaises(errors.ObjectNotLocked,
1281
 
                          repo._pack_collection.ensure_loaded)
 
892
                          packs.ensure_loaded)
1282
893
 
1283
894
    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
 
895
        packs = self.get_packs()
1287
896
        self.assertEqual([1],
1288
897
            packs.pack_distribution(1))
1289
898
        self.assertEqual([1, 1],
1305
914
 
1306
915
    def test_pack_distribution_stable_at_boundaries(self):
1307
916
        """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
 
917
        packs = self.get_packs()
1311
918
        # in 10s:
1312
919
        self.assertEqual([10], packs.pack_distribution(10))
1313
920
        self.assertEqual([10, 1], packs.pack_distribution(11))
1322
929
        self.assertEqual([100, 100, 10, 1], packs.pack_distribution(211))
1323
930
 
1324
931
    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
 
932
        packs = self.get_packs()
1328
933
        existing_packs = [(2000, "big"), (9, "medium")]
1329
934
        # rev count - 2009 -> 2x1000 + 9x1
1330
935
        pack_operations = packs.plan_autopack_combinations(
1332
937
        self.assertEqual([], pack_operations)
1333
938
 
1334
939
    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
 
940
        packs = self.get_packs()
1338
941
        existing_packs = [(2000, "big"), (9, "medium"), (1, "single")]
1339
942
        # rev count - 2010 -> 2x1000 + 1x10
1340
943
        pack_operations = packs.plan_autopack_combinations(
1342
945
        self.assertEqual([], pack_operations)
1343
946
 
1344
947
    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
 
948
        packs = self.get_packs()
1348
949
        existing_packs = [(1999, "big"), (9, "medium"), (1, "single2"),
1349
950
            (1, "single1")]
1350
951
        # rev count - 2010 -> 2x1000 + 1x10 (3)
1351
952
        pack_operations = packs.plan_autopack_combinations(
1352
953
            existing_packs, [1000, 1000, 10])
1353
 
        self.assertEqual([[2, ["single2", "single1"]], [0, []]], pack_operations)
 
954
        self.assertEqual([[2, ["single2", "single1"]]], pack_operations)
 
955
 
 
956
    def test_plan_pack_operations_creates_a_single_op(self):
 
957
        packs = self.get_packs()
 
958
        existing_packs = [(50, 'a'), (40, 'b'), (30, 'c'), (10, 'd'),
 
959
                          (10, 'e'), (6, 'f'), (4, 'g')]
 
960
        # rev count 150 -> 1x100 and 5x10
 
961
        # The two size 10 packs do not need to be touched. The 50, 40, 30 would
 
962
        # be combined into a single 120 size pack, and the 6 & 4 would
 
963
        # becombined into a size 10 pack. However, if we have to rewrite them,
 
964
        # we save a pack file with no increased I/O by putting them into the
 
965
        # same file.
 
966
        distribution = packs.pack_distribution(150)
 
967
        pack_operations = packs.plan_autopack_combinations(existing_packs,
 
968
                                                           distribution)
 
969
        self.assertEqual([[130, ['a', 'b', 'c', 'f', 'g']]], pack_operations)
1354
970
 
1355
971
    def test_all_packs_none(self):
1356
972
        format = self.get_format()
1394
1010
        tree.lock_read()
1395
1011
        self.addCleanup(tree.unlock)
1396
1012
        packs = tree.branch.repository._pack_collection
 
1013
        packs.reset()
1397
1014
        packs.ensure_loaded()
1398
1015
        name = packs.names()[0]
1399
1016
        pack_1 = packs.get_pack_by_name(name)
1400
1017
        # 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])
 
1018
        sizes = packs._names[name]
 
1019
        rev_index = GraphIndex(packs._index_transport, name + '.rix', sizes[0])
 
1020
        inv_index = GraphIndex(packs._index_transport, name + '.iix', sizes[1])
 
1021
        txt_index = GraphIndex(packs._index_transport, name + '.tix', sizes[2])
 
1022
        sig_index = GraphIndex(packs._index_transport, name + '.six', sizes[3])
1409
1023
        self.assertEqual(pack_repo.ExistingPack(packs._pack_transport,
1410
1024
            name, rev_index, inv_index, txt_index, sig_index), pack_1)
1411
1025
        # and the same instance should be returned on successive calls.
1412
1026
        self.assertTrue(pack_1 is packs.get_pack_by_name(name))
1413
1027
 
 
1028
    def test_reload_pack_names_new_entry(self):
 
1029
        tree, r, packs, revs = self.make_packs_and_alt_repo()
 
1030
        names = packs.names()
 
1031
        # Add a new pack file into the repository
 
1032
        rev4 = tree.commit('four')
 
1033
        new_names = tree.branch.repository._pack_collection.names()
 
1034
        new_name = set(new_names).difference(names)
 
1035
        self.assertEqual(1, len(new_name))
 
1036
        new_name = new_name.pop()
 
1037
        # The old collection hasn't noticed yet
 
1038
        self.assertEqual(names, packs.names())
 
1039
        self.assertTrue(packs.reload_pack_names())
 
1040
        self.assertEqual(new_names, packs.names())
 
1041
        # And the repository can access the new revision
 
1042
        self.assertEqual({rev4:(revs[-1],)}, r.get_parent_map([rev4]))
 
1043
        self.assertFalse(packs.reload_pack_names())
 
1044
 
 
1045
    def test_reload_pack_names_added_and_removed(self):
 
1046
        tree, r, packs, revs = self.make_packs_and_alt_repo()
 
1047
        names = packs.names()
 
1048
        # Now repack the whole thing
 
1049
        tree.branch.repository.pack()
 
1050
        new_names = tree.branch.repository._pack_collection.names()
 
1051
        # The other collection hasn't noticed yet
 
1052
        self.assertEqual(names, packs.names())
 
1053
        self.assertTrue(packs.reload_pack_names())
 
1054
        self.assertEqual(new_names, packs.names())
 
1055
        self.assertEqual({revs[-1]:(revs[-2],)}, r.get_parent_map([revs[-1]]))
 
1056
        self.assertFalse(packs.reload_pack_names())
 
1057
 
 
1058
    def test_autopack_reloads_and_stops(self):
 
1059
        tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
 
1060
        # After we have determined what needs to be autopacked, trigger a
 
1061
        # full-pack via the other repo which will cause us to re-evaluate and
 
1062
        # decide we don't need to do anything
 
1063
        orig_execute = packs._execute_pack_operations
 
1064
        def _munged_execute_pack_ops(*args, **kwargs):
 
1065
            tree.branch.repository.pack()
 
1066
            return orig_execute(*args, **kwargs)
 
1067
        packs._execute_pack_operations = _munged_execute_pack_ops
 
1068
        packs._max_pack_count = lambda x: 1
 
1069
        packs.pack_distribution = lambda x: [10]
 
1070
        self.assertFalse(packs.autopack())
 
1071
        self.assertEqual(1, len(packs.names()))
 
1072
        self.assertEqual(tree.branch.repository._pack_collection.names(),
 
1073
                         packs.names())
 
1074
 
1414
1075
 
1415
1076
class TestPack(TestCaseWithTransport):
1416
1077
    """Tests for the Pack object."""
1470
1131
        pack_transport = self.get_transport('pack')
1471
1132
        index_transport = self.get_transport('index')
1472
1133
        upload_transport.mkdir('.')
1473
 
        pack = pack_repo.NewPack(upload_transport, index_transport,
1474
 
            pack_transport)
1475
 
        self.assertIsInstance(pack.revision_index, InMemoryGraphIndex)
1476
 
        self.assertIsInstance(pack.inventory_index, InMemoryGraphIndex)
1477
 
        self.assertIsInstance(pack._hash, type(md5.new()))
 
1134
        collection = pack_repo.RepositoryPackCollection(
 
1135
            repo=None,
 
1136
            transport=self.get_transport('.'),
 
1137
            index_transport=index_transport,
 
1138
            upload_transport=upload_transport,
 
1139
            pack_transport=pack_transport,
 
1140
            index_builder_class=BTreeBuilder,
 
1141
            index_class=BTreeGraphIndex,
 
1142
            use_chk_index=False)
 
1143
        pack = pack_repo.NewPack(collection)
 
1144
        self.assertIsInstance(pack.revision_index, BTreeBuilder)
 
1145
        self.assertIsInstance(pack.inventory_index, BTreeBuilder)
 
1146
        self.assertIsInstance(pack._hash, type(osutils.md5()))
1478
1147
        self.assertTrue(pack.upload_transport is upload_transport)
1479
1148
        self.assertTrue(pack.index_transport is index_transport)
1480
1149
        self.assertTrue(pack.pack_transport is pack_transport)
1487
1156
class TestPacker(TestCaseWithTransport):
1488
1157
    """Tests for the packs repository Packer class."""
1489
1158
 
1490
 
    # To date, this class has been factored out and nothing new added to it;
1491
 
    # thus there are not yet any tests.
1492
 
 
1493
 
 
1494
 
class TestInterDifferingSerializer(TestCaseWithTransport):
1495
 
 
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)
 
1159
    def test_pack_optimizes_pack_order(self):
 
1160
        builder = self.make_branch_builder('.')
 
1161
        builder.start_series()
 
1162
        builder.build_snapshot('A', None, [
 
1163
            ('add', ('', 'root-id', 'directory', None)),
 
1164
            ('add', ('f', 'f-id', 'file', 'content\n'))])
 
1165
        builder.build_snapshot('B', ['A'],
 
1166
            [('modify', ('f-id', 'new-content\n'))])
 
1167
        builder.build_snapshot('C', ['B'],
 
1168
            [('modify', ('f-id', 'third-content\n'))])
 
1169
        builder.build_snapshot('D', ['C'],
 
1170
            [('modify', ('f-id', 'fourth-content\n'))])
 
1171
        b = builder.get_branch()
 
1172
        b.lock_read()
 
1173
        builder.finish_series()
 
1174
        self.addCleanup(b.unlock)
 
1175
        # At this point, we should have 4 pack files available
 
1176
        # Because of how they were built, they correspond to
 
1177
        # ['D', 'C', 'B', 'A']
 
1178
        packs = b.repository._pack_collection.packs
 
1179
        packer = pack_repo.Packer(b.repository._pack_collection,
 
1180
                                  packs, 'testing',
 
1181
                                  revision_ids=['B', 'C'])
 
1182
        # Now, when we are copying the B & C revisions, their pack files should
 
1183
        # be moved to the front of the stack
 
1184
        # The new ordering moves B & C to the front of the .packs attribute,
 
1185
        # and leaves the others in the original order.
 
1186
        new_packs = [packs[1], packs[2], packs[0], packs[3]]
 
1187
        new_pack = packer.pack()
 
1188
        self.assertEqual(new_packs, packer.packs)
 
1189
 
 
1190
 
 
1191
class TestOptimisingPacker(TestCaseWithTransport):
 
1192
    """Tests for the OptimisingPacker class."""
 
1193
 
 
1194
    def get_pack_collection(self):
 
1195
        repo = self.make_repository('.')
 
1196
        return repo._pack_collection
 
1197
 
 
1198
    def test_open_pack_will_optimise(self):
 
1199
        packer = pack_repo.OptimisingPacker(self.get_pack_collection(),
 
1200
                                            [], '.test')
 
1201
        new_pack = packer.open_pack()
 
1202
        self.assertIsInstance(new_pack, pack_repo.NewPack)
 
1203
        self.assertTrue(new_pack.revision_index._optimize_for_size)
 
1204
        self.assertTrue(new_pack.inventory_index._optimize_for_size)
 
1205
        self.assertTrue(new_pack.text_index._optimize_for_size)
 
1206
        self.assertTrue(new_pack.signature_index._optimize_for_size)
 
1207
 
 
1208
 
 
1209
class TestGCCHKPackCollection(TestCaseWithTransport):
 
1210
 
 
1211
    def test_stream_source_to_gc(self):
 
1212
        source = self.make_repository('source', format='development6-rich-root')
 
1213
        target = self.make_repository('target', format='development6-rich-root')
 
1214
        stream = source._get_source(target._format)
 
1215
        self.assertIsInstance(stream, groupcompress_repo.GroupCHKStreamSource)
 
1216
 
 
1217
    def test_stream_source_to_non_gc(self):
 
1218
        source = self.make_repository('source', format='development6-rich-root')
 
1219
        target = self.make_repository('target', format='rich-root-pack')
 
1220
        stream = source._get_source(target._format)
 
1221
        # We don't want the child GroupCHKStreamSource
 
1222
        self.assertIs(type(stream), repository.StreamSource)
 
1223
 
 
1224
    def test_get_stream_for_missing_keys_includes_all_chk_refs(self):
 
1225
        source_builder = self.make_branch_builder('source',
 
1226
                            format='development6-rich-root')
 
1227
        # We have to build a fairly large tree, so that we are sure the chk
 
1228
        # pages will have split into multiple pages.
 
1229
        entries = [('add', ('', 'a-root-id', 'directory', None))]
 
1230
        for i in 'abcdefghijklmnopqrstuvwxyz123456789':
 
1231
            for j in 'abcdefghijklmnopqrstuvwxyz123456789':
 
1232
                fname = i + j
 
1233
                fid = fname + '-id'
 
1234
                content = 'content for %s\n' % (fname,)
 
1235
                entries.append(('add', (fname, fid, 'file', content)))
 
1236
        source_builder.start_series()
 
1237
        source_builder.build_snapshot('rev-1', None, entries)
 
1238
        # Now change a few of them, so we get a few new pages for the second
 
1239
        # revision
 
1240
        source_builder.build_snapshot('rev-2', ['rev-1'], [
 
1241
            ('modify', ('aa-id', 'new content for aa-id\n')),
 
1242
            ('modify', ('cc-id', 'new content for cc-id\n')),
 
1243
            ('modify', ('zz-id', 'new content for zz-id\n')),
 
1244
            ])
 
1245
        source_builder.finish_series()
 
1246
        source_branch = source_builder.get_branch()
 
1247
        source_branch.lock_read()
 
1248
        self.addCleanup(source_branch.unlock)
 
1249
        target = self.make_repository('target', format='development6-rich-root')
 
1250
        source = source_branch.repository._get_source(target._format)
 
1251
        self.assertIsInstance(source, groupcompress_repo.GroupCHKStreamSource)
 
1252
 
 
1253
        # On a regular pass, getting the inventories and chk pages for rev-2
 
1254
        # would only get the newly created chk pages
 
1255
        search = graph.SearchResult(set(['rev-2']), set(['rev-1']), 1,
 
1256
                                    set(['rev-2']))
 
1257
        simple_chk_records = []
 
1258
        for vf_name, substream in source.get_stream(search):
 
1259
            if vf_name == 'chk_bytes':
 
1260
                for record in substream:
 
1261
                    simple_chk_records.append(record.key)
 
1262
            else:
 
1263
                for _ in substream:
 
1264
                    continue
 
1265
        # 3 pages, the root (InternalNode), + 2 pages which actually changed
 
1266
        self.assertEqual([('sha1:91481f539e802c76542ea5e4c83ad416bf219f73',),
 
1267
                          ('sha1:4ff91971043668583985aec83f4f0ab10a907d3f',),
 
1268
                          ('sha1:81e7324507c5ca132eedaf2d8414ee4bb2226187',),
 
1269
                          ('sha1:b101b7da280596c71a4540e9a1eeba8045985ee0',)],
 
1270
                         simple_chk_records)
 
1271
        # Now, when we do a similar call using 'get_stream_for_missing_keys'
 
1272
        # we should get a much larger set of pages.
 
1273
        missing = [('inventories', 'rev-2')]
 
1274
        full_chk_records = []
 
1275
        for vf_name, substream in source.get_stream_for_missing_keys(missing):
 
1276
            if vf_name == 'inventories':
 
1277
                for record in substream:
 
1278
                    self.assertEqual(('rev-2',), record.key)
 
1279
            elif vf_name == 'chk_bytes':
 
1280
                for record in substream:
 
1281
                    full_chk_records.append(record.key)
 
1282
            else:
 
1283
                self.fail('Should not be getting a stream of %s' % (vf_name,))
 
1284
        # We have 257 records now. This is because we have 1 root page, and 256
 
1285
        # leaf pages in a complete listing.
 
1286
        self.assertEqual(257, len(full_chk_records))
 
1287
        self.assertSubset(simple_chk_records, full_chk_records)