← 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: Canonical.com Patch Queue Manager
  • Date: 2007-11-04 18:51:39 UTC
  • mfrom: (2961.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20071104185139-kaio3sneodg2kp71
Authentication ring implementation (read-only)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_repository.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
32
32
                           UnknownFormatError,
33
33
                           UnsupportedFormatError,
34
34
                           )
35
 
from bzrlib import graph
36
35
from bzrlib.index import GraphIndex, InMemoryGraphIndex
37
36
from bzrlib.repository import RepositoryFormat
38
37
from bzrlib.smart import server
39
38
from bzrlib.tests import (
40
39
    TestCase,
41
40
    TestCaseWithTransport,
42
 
    TestSkipped,
43
41
    test_knit,
44
42
    )
45
 
from bzrlib.transport import (
46
 
    fakenfs,
47
 
    get_transport,
48
 
    )
 
43
from bzrlib.transport import get_transport
49
44
from bzrlib.transport.memory import MemoryServer
50
45
from bzrlib.util import bencode
51
46
from bzrlib import (
52
47
    bzrdir,
53
48
    errors,
54
49
    inventory,
55
 
    progress,
56
50
    repository,
57
51
    revision as _mod_revision,
58
52
    symbol_versioning,
162
156
 
163
157
class TestFormat6(TestCaseWithTransport):
164
158
 
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)
170
 
 
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)
176
 
 
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)
182
 
 
183
159
    def test_no_ancestry_weave(self):
184
160
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
185
161
        repo = weaverepo.RepositoryFormat6().initialize(control)
189
165
                          control.transport.get,
190
166
                          'ancestry.weave')
191
167
 
192
 
    def test_supports_external_lookups(self):
 
168
    def test_exposed_versioned_files_are_marked_dirty(self):
193
169
        control = bzrdir.BzrDirFormat6().initialize(self.get_url())
194
170
        repo = weaverepo.RepositoryFormat6().initialize(control)
195
 
        self.assertFalse(repo._format.supports_external_lookups)
 
171
        repo.lock_write()
 
172
        inv = repo.get_inventory_weave()
 
173
        repo.unlock()
 
174
        self.assertRaises(errors.OutSideTransaction,
 
175
            inv.add_lines, 'foo', [], [])
196
176
 
197
177
 
198
178
class TestFormat7(TestCaseWithTransport):
199
 
 
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)
205
 
 
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)
211
 
 
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)
217
 
 
 
179
    
218
180
    def test_disk_layout(self):
219
181
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
220
182
        repo = weaverepo.RepositoryFormat7().initialize(control)
236
198
                             'w\n'
237
199
                             'W\n',
238
200
                             t.get('inventory.weave').read())
239
 
        # Creating a file with id Foo:Bar results in a non-escaped file name on
240
 
        # disk.
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'
248
 
            'i\n'
249
 
            '1 7fe70820e08a1aac0ef224d9c66ab66831cc4ab1\n'
250
 
            'n first\n'
251
 
            '\n'
252
 
            'w\n'
253
 
            '{ 0\n'
254
 
            '. content\n'
255
 
            '}\n'
256
 
            'W\n',
257
 
            t.get('weaves/74/Foo%3ABar.weave').read())
258
201
 
259
202
    def test_shared_disk_layout(self):
260
203
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
335
278
                             'W\n',
336
279
                             t.get('inventory.weave').read())
337
280
 
338
 
    def test_supports_external_lookups(self):
 
281
    def test_exposed_versioned_files_are_marked_dirty(self):
339
282
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
340
283
        repo = weaverepo.RepositoryFormat7().initialize(control)
341
 
        self.assertFalse(repo._format.supports_external_lookups)
 
284
        repo.lock_write()
 
285
        inv = repo.get_inventory_weave()
 
286
        repo.unlock()
 
287
        self.assertRaises(errors.OutSideTransaction,
 
288
            inv.add_lines, 'foo', [], [])
342
289
 
343
290
 
344
291
class TestFormatKnit1(TestCaseWithTransport):
345
292
    
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)
351
 
 
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)
357
 
 
358
293
    def test_disk_layout(self):
359
294
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
360
295
        repo = knitrepo.RepositoryFormatKnit1().initialize(control)
374
309
        # self.assertEqualDiff('', t.get('lock').read())
375
310
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
376
311
        self.check_knits(t)
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  :')
385
312
 
386
 
    def assertHasKnit(self, t, knit_name, extra_content=''):
 
313
    def assertHasKnit(self, t, knit_name):
387
314
        """Assert that knit_name exists on t."""
388
 
        self.assertEqualDiff('# bzr knit index 8\n' + extra_content,
 
315
        self.assertEqualDiff('# bzr knit index 8\n',
389
316
                             t.get(knit_name + '.kndx').read())
 
317
        # no default content
 
318
        self.assertTrue(t.has(knit_name + '.knit'))
390
319
 
391
320
    def check_knits(self, t):
392
321
        """check knit content for a repository."""
436
365
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
437
366
        self.check_knits(t)
438
367
 
 
368
    def test_exposed_versioned_files_are_marked_dirty(self):
 
369
        format = bzrdir.BzrDirMetaFormat1()
 
370
        format.repository_format = knitrepo.RepositoryFormatKnit1()
 
371
        repo = self.make_repository('.', format=format)
 
372
        repo.lock_write()
 
373
        inv = repo.get_inventory_weave()
 
374
        repo.unlock()
 
375
        self.assertRaises(errors.OutSideTransaction,
 
376
            inv.add_lines, 'foo', [], [])
 
377
 
439
378
    def test_deserialise_sets_root_revision(self):
440
379
        """We must have a inventory.root.revision
441
380
 
458
397
        # Arguably, the deserialise_inventory should detect a mismatch, and
459
398
        # raise an error, rather than silently using one revision_id over the
460
399
        # other.
461
 
        self.assertRaises(AssertionError, repo.deserialise_inventory,
462
 
            'test-rev-id', inv_xml)
463
 
        inv = repo.deserialise_inventory('other-rev-id', inv_xml)
 
400
        inv = repo.deserialise_inventory('test-rev-id', inv_xml)
464
401
        self.assertEqual('other-rev-id', inv.root.revision)
465
402
 
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)
 
403
 
 
404
class KnitRepositoryStreamTests(test_knit.KnitTests):
 
405
    """Tests for knitrepo._get_stream_as_bytes."""
 
406
 
 
407
    def test_get_stream_as_bytes(self):
 
408
        # Make a simple knit
 
409
        k1 = self.make_test_knit()
 
410
        k1.add_lines('text-a', [], test_knit.split_lines(test_knit.TEXT_1))
 
411
        
 
412
        # Serialise it, check the output.
 
413
        bytes = knitrepo._get_stream_as_bytes(k1, ['text-a'])
 
414
        data = bencode.bdecode(bytes)
 
415
        format, record = data
 
416
        self.assertEqual('knit-plain', format)
 
417
        self.assertEqual(['text-a', ['fulltext'], []], record[:3])
 
418
        self.assertRecordContentEqual(k1, 'text-a', record[3])
 
419
 
 
420
    def test_get_stream_as_bytes_all(self):
 
421
        """Get a serialised data stream for all the records in a knit.
 
422
 
 
423
        Much like test_get_stream_all, except for get_stream_as_bytes.
 
424
        """
 
425
        k1 = self.make_test_knit()
 
426
        # Insert the same data as BasicKnitTests.test_knit_join, as they seem
 
427
        # to cover a range of cases (no parents, one parent, multiple parents).
 
428
        test_data = [
 
429
            ('text-a', [], test_knit.TEXT_1),
 
430
            ('text-b', ['text-a'], test_knit.TEXT_1),
 
431
            ('text-c', [], test_knit.TEXT_1),
 
432
            ('text-d', ['text-c'], test_knit.TEXT_1),
 
433
            ('text-m', ['text-b', 'text-d'], test_knit.TEXT_1),
 
434
           ]
 
435
        expected_data_list = [
 
436
            # version, options, parents
 
437
            ('text-a', ['fulltext'], []),
 
438
            ('text-b', ['line-delta'], ['text-a']),
 
439
            ('text-c', ['fulltext'], []),
 
440
            ('text-d', ['line-delta'], ['text-c']),
 
441
            ('text-m', ['line-delta'], ['text-b', 'text-d']),
 
442
            ]
 
443
        for version_id, parents, lines in test_data:
 
444
            k1.add_lines(version_id, parents, test_knit.split_lines(lines))
 
445
 
 
446
        bytes = knitrepo._get_stream_as_bytes(
 
447
            k1, ['text-a', 'text-b', 'text-c', 'text-d', 'text-m'])
 
448
 
 
449
        data = bencode.bdecode(bytes)
 
450
        format = data.pop(0)
 
451
        self.assertEqual('knit-plain', format)
 
452
 
 
453
        for expected, actual in zip(expected_data_list, data):
 
454
            expected_version = expected[0]
 
455
            expected_options = expected[1]
 
456
            expected_parents = expected[2]
 
457
            version, options, parents, bytes = actual
 
458
            self.assertEqual(expected_version, version)
 
459
            self.assertEqual(expected_options, options)
 
460
            self.assertEqual(expected_parents, parents)
 
461
            self.assertRecordContentEqual(k1, version, bytes)
470
462
 
471
463
 
472
464
class DummyRepository(object):
579
571
                                                        repo_b).__class__)
580
572
 
581
573
 
 
574
class TestInterRemoteToOther(TestCaseWithTransport):
 
575
 
 
576
    def make_remote_repository(self, path, backing_format=None):
 
577
        """Make a RemoteRepository object backed by a real repository that will
 
578
        be created at the given path."""
 
579
        self.make_repository(path, format=backing_format)
 
580
        smart_server = server.SmartTCPServer_for_testing()
 
581
        smart_server.setUp()
 
582
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
583
        self.addCleanup(smart_server.tearDown)
 
584
        remote_bzrdir = bzrdir.BzrDir.open_from_transport(remote_transport)
 
585
        remote_repo = remote_bzrdir.open_repository()
 
586
        return remote_repo
 
587
 
 
588
    def test_is_compatible_same_format(self):
 
589
        """InterRemoteToOther is compatible with a remote repository and a
 
590
        second repository that have the same format."""
 
591
        local_repo = self.make_repository('local')
 
592
        remote_repo = self.make_remote_repository('remote')
 
593
        is_compatible = repository.InterRemoteToOther.is_compatible
 
594
        self.assertTrue(
 
595
            is_compatible(remote_repo, local_repo),
 
596
            "InterRemoteToOther(%r, %r) is false" % (remote_repo, local_repo))
 
597
          
 
598
    def test_is_incompatible_different_format(self):
 
599
        local_repo = self.make_repository('local', 'dirstate')
 
600
        remote_repo = self.make_remote_repository('a', 'dirstate-with-subtree')
 
601
        is_compatible = repository.InterRemoteToOther.is_compatible
 
602
        self.assertFalse(
 
603
            is_compatible(remote_repo, local_repo),
 
604
            "InterRemoteToOther(%r, %r) is true" % (local_repo, remote_repo))
 
605
 
 
606
    def test_is_incompatible_different_format_both_remote(self):
 
607
        remote_repo_a = self.make_remote_repository(
 
608
            'a', 'dirstate-with-subtree')
 
609
        remote_repo_b = self.make_remote_repository('b', 'dirstate')
 
610
        is_compatible = repository.InterRemoteToOther.is_compatible
 
611
        self.assertFalse(
 
612
            is_compatible(remote_repo_a, remote_repo_b),
 
613
            "InterRemoteToOther(%r, %r) is true"
 
614
            % (remote_repo_a, remote_repo_b))
 
615
 
 
616
 
582
617
class TestRepositoryConverter(TestCaseWithTransport):
583
618
 
584
619
    def test_convert_empty(self):
606
641
 
607
642
class TestRepositoryFormatKnit3(TestCaseWithTransport):
608
643
 
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)
615
 
 
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)
622
 
 
623
644
    def test_convert(self):
624
645
        """Ensure the upgrade adds weaves for roots"""
625
646
        format = bzrdir.BzrDirMetaFormat1()
627
648
        tree = self.make_branch_and_tree('.', format)
628
649
        tree.commit("Dull commit", rev_id="dull")
629
650
        revision_tree = tree.branch.repository.revision_tree('dull')
630
 
        revision_tree.lock_read()
631
 
        try:
632
 
            self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
633
 
                revision_tree.inventory.root.file_id)
634
 
        finally:
635
 
            revision_tree.unlock()
 
651
        self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
 
652
            revision_tree.inventory.root.file_id)
636
653
        format = bzrdir.BzrDirMetaFormat1()
637
654
        format.repository_format = knitrepo.RepositoryFormatKnit3()
638
655
        upgrade.Convert('.', format)
639
656
        tree = workingtree.WorkingTree.open('.')
640
657
        revision_tree = tree.branch.repository.revision_tree('dull')
641
 
        revision_tree.lock_read()
642
 
        try:
643
 
            revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
644
 
        finally:
645
 
            revision_tree.unlock()
 
658
        revision_tree.get_file_lines(revision_tree.inventory.root.file_id)
646
659
        tree.commit("Another dull commit", rev_id='dull2')
647
660
        revision_tree = tree.branch.repository.revision_tree('dull2')
648
 
        revision_tree.lock_read()
649
 
        self.addCleanup(revision_tree.unlock)
650
661
        self.assertEqual('dull', revision_tree.inventory.root.revision)
651
662
 
652
 
    def test_supports_external_lookups(self):
 
663
    def test_exposed_versioned_files_are_marked_dirty(self):
653
664
        format = bzrdir.BzrDirMetaFormat1()
654
665
        format.repository_format = knitrepo.RepositoryFormatKnit3()
655
666
        repo = self.make_repository('.', format=format)
656
 
        self.assertFalse(repo._format.supports_external_lookups)
 
667
        repo.lock_write()
 
668
        inv = repo.get_inventory_weave()
 
669
        repo.unlock()
 
670
        self.assertRaises(errors.OutSideTransaction,
 
671
            inv.add_lines, 'foo', [], [])
657
672
 
658
673
 
659
674
class TestWithBrokenRepo(TestCaseWithTransport):
726
741
        entry.revision = revision
727
742
        entry.text_size = 0
728
743
        inv.add(entry)
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'])
 
744
        vf = repo.weave_store.get_weave_or_empty(file_id,
 
745
                                                 repo.get_transaction())
 
746
        vf.add_lines(revision, parents, ['line\n'])
732
747
 
733
748
    def test_insert_from_broken_repo(self):
734
749
        """Inserting a data stream from a broken repository won't silently
736
751
        """
737
752
        broken_repo = self.make_broken_repository()
738
753
        empty_repo = self.make_repository('empty-repo')
739
 
        self.assertRaises(errors.RevisionNotPresent, empty_repo.fetch, broken_repo)
 
754
        stream = broken_repo.get_data_stream(['rev1a', 'rev2', 'rev3'])
 
755
        empty_repo.lock_write()
 
756
        self.addCleanup(empty_repo.unlock)
 
757
        empty_repo.start_write_group()
 
758
        try:
 
759
            self.assertRaises(
 
760
                errors.KnitCorrupt, empty_repo.insert_data_stream, stream)
 
761
        finally:
 
762
            empty_repo.abort_write_group()
 
763
 
 
764
 
 
765
class TestKnitPackNoSubtrees(TestCaseWithTransport):
 
766
 
 
767
    def get_format(self):
 
768
        return bzrdir.format_registry.make_bzrdir('knitpack-experimental')
 
769
 
 
770
    def test_disk_layout(self):
 
771
        format = self.get_format()
 
772
        repo = self.make_repository('.', format=format)
 
773
        # in case of side effects of locking.
 
774
        repo.lock_write()
 
775
        repo.unlock()
 
776
        t = repo.bzrdir.get_repository_transport(None)
 
777
        self.check_format(t)
 
778
        # XXX: no locks left when unlocked at the moment
 
779
        # self.assertEqualDiff('', t.get('lock').read())
 
780
        self.check_databases(t)
 
781
 
 
782
    def check_format(self, t):
 
783
        self.assertEqualDiff(
 
784
            "Bazaar pack repository format 1 (needs bzr 0.92)\n",
 
785
                             t.get('format').read())
 
786
 
 
787
    def assertHasKndx(self, t, knit_name):
 
788
        """Assert that knit_name exists on t."""
 
789
        self.assertEqualDiff('# bzr knit index 8\n',
 
790
                             t.get(knit_name + '.kndx').read())
 
791
 
 
792
    def assertHasNoKndx(self, t, knit_name):
 
793
        """Assert that knit_name has no index on t."""
 
794
        self.assertFalse(t.has(knit_name + '.kndx'))
 
795
 
 
796
    def assertHasNoKnit(self, t, knit_name):
 
797
        """Assert that knit_name exists on t."""
 
798
        # no default content
 
799
        self.assertFalse(t.has(knit_name + '.knit'))
 
800
 
 
801
    def check_databases(self, t):
 
802
        """check knit content for a repository."""
 
803
        # check conversion worked
 
804
        self.assertHasNoKndx(t, 'inventory')
 
805
        self.assertHasNoKnit(t, 'inventory')
 
806
        self.assertHasNoKndx(t, 'revisions')
 
807
        self.assertHasNoKnit(t, 'revisions')
 
808
        self.assertHasNoKndx(t, 'signatures')
 
809
        self.assertHasNoKnit(t, 'signatures')
 
810
        self.assertFalse(t.has('knits'))
 
811
        # revision-indexes file-container directory
 
812
        self.assertEqual([],
 
813
            list(GraphIndex(t, 'pack-names', None).iter_all_entries()))
 
814
        self.assertTrue(S_ISDIR(t.stat('packs').st_mode))
 
815
        self.assertTrue(S_ISDIR(t.stat('upload').st_mode))
 
816
        self.assertTrue(S_ISDIR(t.stat('indices').st_mode))
 
817
        self.assertTrue(S_ISDIR(t.stat('obsolete_packs').st_mode))
 
818
 
 
819
    def test_shared_disk_layout(self):
 
820
        format = self.get_format()
 
821
        repo = self.make_repository('.', shared=True, format=format)
 
822
        # we want:
 
823
        t = repo.bzrdir.get_repository_transport(None)
 
824
        self.check_format(t)
 
825
        # XXX: no locks left when unlocked at the moment
 
826
        # self.assertEqualDiff('', t.get('lock').read())
 
827
        # We should have a 'shared-storage' marker file.
 
828
        self.assertEqualDiff('', t.get('shared-storage').read())
 
829
        self.check_databases(t)
 
830
 
 
831
    def test_shared_no_tree_disk_layout(self):
 
832
        format = self.get_format()
 
833
        repo = self.make_repository('.', shared=True, format=format)
 
834
        repo.set_make_working_trees(False)
 
835
        # we want:
 
836
        t = repo.bzrdir.get_repository_transport(None)
 
837
        self.check_format(t)
 
838
        # XXX: no locks left when unlocked at the moment
 
839
        # self.assertEqualDiff('', t.get('lock').read())
 
840
        # We should have a 'shared-storage' marker file.
 
841
        self.assertEqualDiff('', t.get('shared-storage').read())
 
842
        # We should have a marker for the no-working-trees flag.
 
843
        self.assertEqualDiff('', t.get('no-working-trees').read())
 
844
        # The marker should go when we toggle the setting.
 
845
        repo.set_make_working_trees(True)
 
846
        self.assertFalse(t.has('no-working-trees'))
 
847
        self.check_databases(t)
 
848
 
 
849
    def test_adding_revision_creates_pack_indices(self):
 
850
        format = self.get_format()
 
851
        tree = self.make_branch_and_tree('.', format=format)
 
852
        trans = tree.branch.repository.bzrdir.get_repository_transport(None)
 
853
        self.assertEqual([],
 
854
            list(GraphIndex(trans, 'pack-names', None).iter_all_entries()))
 
855
        tree.commit('foobarbaz')
 
856
        index = GraphIndex(trans, 'pack-names', None)
 
857
        index_nodes = list(index.iter_all_entries())
 
858
        self.assertEqual(1, len(index_nodes))
 
859
        node = index_nodes[0]
 
860
        name = node[1][0]
 
861
        # the pack sizes should be listed in the index
 
862
        pack_value = node[2]
 
863
        sizes = [int(digits) for digits in pack_value.split(' ')]
 
864
        for size, suffix in zip(sizes, ['.rix', '.iix', '.tix', '.six']):
 
865
            stat = trans.stat('indices/%s%s' % (name, suffix))
 
866
            self.assertEqual(size, stat.st_size)
 
867
 
 
868
    def test_pulling_nothing_leads_to_no_new_names(self):
 
869
        format = self.get_format()
 
870
        tree1 = self.make_branch_and_tree('1', format=format)
 
871
        tree2 = self.make_branch_and_tree('2', format=format)
 
872
        tree1.branch.repository.fetch(tree2.branch.repository)
 
873
        trans = tree1.branch.repository.bzrdir.get_repository_transport(None)
 
874
        self.assertEqual([],
 
875
            list(GraphIndex(trans, 'pack-names', None).iter_all_entries()))
 
876
 
 
877
    def test_commit_across_pack_shape_boundary_autopacks(self):
 
878
        format = self.get_format()
 
879
        tree = self.make_branch_and_tree('.', format=format)
 
880
        trans = tree.branch.repository.bzrdir.get_repository_transport(None)
 
881
        # This test could be a little cheaper by replacing the packs
 
882
        # attribute on the repository to allow a different pack distribution
 
883
        # and max packs policy - so we are checking the policy is honoured
 
884
        # in the test. But for now 11 commits is not a big deal in a single
 
885
        # test.
 
886
        for x in range(9):
 
887
            tree.commit('commit %s' % x)
 
888
        # there should be 9 packs:
 
889
        index = GraphIndex(trans, 'pack-names', None)
 
890
        self.assertEqual(9, len(list(index.iter_all_entries())))
 
891
        # committing one more should coalesce to 1 of 10.
 
892
        tree.commit('commit triggering pack')
 
893
        index = GraphIndex(trans, 'pack-names', None)
 
894
        self.assertEqual(1, len(list(index.iter_all_entries())))
 
895
        # packing should not damage data
 
896
        tree = tree.bzrdir.open_workingtree()
 
897
        check_result = tree.branch.repository.check(
 
898
            [tree.branch.last_revision()])
 
899
        # XXX: Todo check packs obsoleted correctly - old packs and indices
 
900
        # in the obsolete_packs directory.
 
901
        large_pack_name = list(index.iter_all_entries())[0][1][0]
 
902
        # finally, committing again should not touch the large pack.
 
903
        tree.commit('commit not triggering pack')
 
904
        index = GraphIndex(trans, 'pack-names', None)
 
905
        self.assertEqual(2, len(list(index.iter_all_entries())))
 
906
        pack_names = [node[1][0] for node in index.iter_all_entries()]
 
907
        self.assertTrue(large_pack_name in pack_names)
 
908
 
 
909
    def test_pack_after_two_commits_packs_everything(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
        tree.commit('start')
 
914
        tree.commit('more work')
 
915
        tree.branch.repository.pack()
 
916
        # there should be 1 pack:
 
917
        index = GraphIndex(trans, 'pack-names', None)
 
918
        self.assertEqual(1, len(list(index.iter_all_entries())))
 
919
        self.assertEqual(2, len(tree.branch.repository.all_revision_ids()))
 
920
 
 
921
    def test_pack_repositories_support_multiple_write_locks(self):
 
922
        format = self.get_format()
 
923
        self.make_repository('.', shared=True, format=format)
 
924
        r1 = repository.Repository.open('.')
 
925
        r2 = repository.Repository.open('.')
 
926
        r1.lock_write()
 
927
        self.addCleanup(r1.unlock)
 
928
        r2.lock_write()
 
929
        r2.unlock()
 
930
 
 
931
    def _add_text(self, repo, fileid):
 
932
        """Add a text to the repository within a write group."""
 
933
        vf =repo.weave_store.get_weave(fileid, repo.get_transaction())
 
934
        vf.add_lines('samplerev+' + fileid, [], [])
 
935
 
 
936
    def test_concurrent_writers_merge_new_packs(self):
 
937
        format = self.get_format()
 
938
        self.make_repository('.', shared=True, format=format)
 
939
        r1 = repository.Repository.open('.')
 
940
        r2 = repository.Repository.open('.')
 
941
        r1.lock_write()
 
942
        try:
 
943
            # access enough data to load the names list
 
944
            list(r1.all_revision_ids())
 
945
            r2.lock_write()
 
946
            try:
 
947
                # access enough data to load the names list
 
948
                list(r2.all_revision_ids())
 
949
                r1.start_write_group()
 
950
                try:
 
951
                    r2.start_write_group()
 
952
                    try:
 
953
                        self._add_text(r1, 'fileidr1')
 
954
                        self._add_text(r2, 'fileidr2')
 
955
                    except:
 
956
                        r2.abort_write_group()
 
957
                        raise
 
958
                except:
 
959
                    r1.abort_write_group()
 
960
                    raise
 
961
                # both r1 and r2 have open write groups with data in them
 
962
                # created while the other's write group was open.
 
963
                # Commit both which requires a merge to the pack-names.
 
964
                try:
 
965
                    r1.commit_write_group()
 
966
                except:
 
967
                    r1.abort_write_group()
 
968
                    r2.abort_write_group()
 
969
                    raise
 
970
                r2.commit_write_group()
 
971
                # tell r1 to reload from disk
 
972
                r1._pack_collection.reset()
 
973
                # Now both repositories should know about both names
 
974
                r1._pack_collection.ensure_loaded()
 
975
                r2._pack_collection.ensure_loaded()
 
976
                self.assertEqual(r1._pack_collection.names(), r2._pack_collection.names())
 
977
                self.assertEqual(2, len(r1._pack_collection.names()))
 
978
            finally:
 
979
                r2.unlock()
 
980
        finally:
 
981
            r1.unlock()
 
982
 
 
983
    def test_concurrent_writer_second_preserves_dropping_a_pack(self):
 
984
        format = self.get_format()
 
985
        self.make_repository('.', shared=True, format=format)
 
986
        r1 = repository.Repository.open('.')
 
987
        r2 = repository.Repository.open('.')
 
988
        # add a pack to drop
 
989
        r1.lock_write()
 
990
        try:
 
991
            r1.start_write_group()
 
992
            try:
 
993
                self._add_text(r1, 'fileidr1')
 
994
            except:
 
995
                r1.abort_write_group()
 
996
                raise
 
997
            else:
 
998
                r1.commit_write_group()
 
999
            r1._pack_collection.ensure_loaded()
 
1000
            name_to_drop = r1._pack_collection.all_packs()[0].name
 
1001
        finally:
 
1002
            r1.unlock()
 
1003
        r1.lock_write()
 
1004
        try:
 
1005
            # access enough data to load the names list
 
1006
            list(r1.all_revision_ids())
 
1007
            r2.lock_write()
 
1008
            try:
 
1009
                # access enough data to load the names list
 
1010
                list(r2.all_revision_ids())
 
1011
                r1._pack_collection.ensure_loaded()
 
1012
                try:
 
1013
                    r2.start_write_group()
 
1014
                    try:
 
1015
                        # in r1, drop the pack
 
1016
                        r1._pack_collection._remove_pack_from_memory(
 
1017
                            r1._pack_collection.get_pack_by_name(name_to_drop))
 
1018
                        # in r2, add a pack
 
1019
                        self._add_text(r2, 'fileidr2')
 
1020
                    except:
 
1021
                        r2.abort_write_group()
 
1022
                        raise
 
1023
                except:
 
1024
                    r1._pack_collection.reset()
 
1025
                    raise
 
1026
                # r1 has a changed names list, and r2 an open write groups with
 
1027
                # changes.
 
1028
                # save r1, and then commit the r2 write group, which requires a
 
1029
                # merge to the pack-names, which should not reinstate
 
1030
                # name_to_drop
 
1031
                try:
 
1032
                    r1._pack_collection._save_pack_names()
 
1033
                    r1._pack_collection.reset()
 
1034
                except:
 
1035
                    r2.abort_write_group()
 
1036
                    raise
 
1037
                try:
 
1038
                    r2.commit_write_group()
 
1039
                except:
 
1040
                    r2.abort_write_group()
 
1041
                    raise
 
1042
                # Now both repositories should now about just one name.
 
1043
                r1._pack_collection.ensure_loaded()
 
1044
                r2._pack_collection.ensure_loaded()
 
1045
                self.assertEqual(r1._pack_collection.names(), r2._pack_collection.names())
 
1046
                self.assertEqual(1, len(r1._pack_collection.names()))
 
1047
                self.assertFalse(name_to_drop in r1._pack_collection.names())
 
1048
            finally:
 
1049
                r2.unlock()
 
1050
        finally:
 
1051
            r1.unlock()
 
1052
 
 
1053
    def test_lock_write_does_not_physically_lock(self):
 
1054
        repo = self.make_repository('.', format=self.get_format())
 
1055
        repo.lock_write()
 
1056
        self.addCleanup(repo.unlock)
 
1057
        self.assertFalse(repo.get_physical_lock_status())
 
1058
 
 
1059
    def prepare_for_break_lock(self):
 
1060
        # Setup the global ui factory state so that a break-lock method call
 
1061
        # will find usable input in the input stream.
 
1062
        old_factory = bzrlib.ui.ui_factory
 
1063
        def restoreFactory():
 
1064
            bzrlib.ui.ui_factory = old_factory
 
1065
        self.addCleanup(restoreFactory)
 
1066
        bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
 
1067
        bzrlib.ui.ui_factory.stdin = StringIO("y\n")
 
1068
 
 
1069
    def test_break_lock_breaks_physical_lock(self):
 
1070
        repo = self.make_repository('.', format=self.get_format())
 
1071
        repo._pack_collection.lock_names()
 
1072
        repo2 = repository.Repository.open('.')
 
1073
        self.assertTrue(repo.get_physical_lock_status())
 
1074
        self.prepare_for_break_lock()
 
1075
        repo2.break_lock()
 
1076
        self.assertFalse(repo.get_physical_lock_status())
 
1077
 
 
1078
    def test_broken_physical_locks_error_on__unlock_names_lock(self):
 
1079
        repo = self.make_repository('.', format=self.get_format())
 
1080
        repo._pack_collection.lock_names()
 
1081
        self.assertTrue(repo.get_physical_lock_status())
 
1082
        repo2 = repository.Repository.open('.')
 
1083
        self.prepare_for_break_lock()
 
1084
        repo2.break_lock()
 
1085
        self.assertRaises(errors.LockBroken, repo._pack_collection._unlock_names)
 
1086
 
 
1087
    def test_fetch_without_find_ghosts_ignores_ghosts(self):
 
1088
        # we want two repositories at this point:
 
1089
        # one with a revision that is a ghost in the other
 
1090
        # repository.
 
1091
        # 'ghost' is present in has_ghost, 'ghost' is absent in 'missing_ghost'.
 
1092
        # 'references' is present in both repositories, and 'tip' is present
 
1093
        # just in has_ghost.
 
1094
        # has_ghost       missing_ghost
 
1095
        #------------------------------
 
1096
        # 'ghost'             -
 
1097
        # 'references'    'references'
 
1098
        # 'tip'               -
 
1099
        # In this test we fetch 'tip' which should not fetch 'ghost'
 
1100
        has_ghost = self.make_repository('has_ghost', format=self.get_format())
 
1101
        missing_ghost = self.make_repository('missing_ghost',
 
1102
            format=self.get_format())
 
1103
 
 
1104
        def add_commit(repo, revision_id, parent_ids):
 
1105
            repo.lock_write()
 
1106
            repo.start_write_group()
 
1107
            inv = inventory.Inventory(revision_id=revision_id)
 
1108
            inv.root.revision = revision_id
 
1109
            root_id = inv.root.file_id
 
1110
            sha1 = repo.add_inventory(revision_id, inv, [])
 
1111
            vf = repo.weave_store.get_weave_or_empty(root_id,
 
1112
                repo.get_transaction())
 
1113
            vf.add_lines(revision_id, [], [])
 
1114
            rev = bzrlib.revision.Revision(timestamp=0,
 
1115
                                           timezone=None,
 
1116
                                           committer="Foo Bar <foo@example.com>",
 
1117
                                           message="Message",
 
1118
                                           inventory_sha1=sha1,
 
1119
                                           revision_id=revision_id)
 
1120
            rev.parent_ids = parent_ids
 
1121
            repo.add_revision(revision_id, rev)
 
1122
            repo.commit_write_group()
 
1123
            repo.unlock()
 
1124
        add_commit(has_ghost, 'ghost', [])
 
1125
        add_commit(has_ghost, 'references', ['ghost'])
 
1126
        add_commit(missing_ghost, 'references', ['ghost'])
 
1127
        add_commit(has_ghost, 'tip', ['references'])
 
1128
        missing_ghost.fetch(has_ghost, 'tip')
 
1129
        # missing ghost now has tip and not ghost.
 
1130
        rev = missing_ghost.get_revision('tip')
 
1131
        inv = missing_ghost.get_inventory('tip')
 
1132
        self.assertRaises(errors.NoSuchRevision,
 
1133
            missing_ghost.get_revision, 'ghost')
 
1134
        self.assertRaises(errors.RevisionNotPresent,
 
1135
            missing_ghost.get_inventory, 'ghost')
 
1136
 
 
1137
 
 
1138
class TestKnitPackSubtrees(TestKnitPackNoSubtrees):
 
1139
 
 
1140
    def get_format(self):
 
1141
        return bzrdir.format_registry.make_bzrdir(
 
1142
            'knitpack-subtree-experimental')
 
1143
 
 
1144
    def check_format(self, t):
 
1145
        self.assertEqualDiff(
 
1146
            "Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n",
 
1147
            t.get('format').read())
740
1148
 
741
1149
 
742
1150
class TestRepositoryPackCollection(TestCaseWithTransport):
743
1151
 
744
1152
    def get_format(self):
745
 
        return bzrdir.format_registry.make_bzrdir('pack-0.92')
 
1153
        return bzrdir.format_registry.make_bzrdir('knitpack-experimental')
746
1154
 
747
1155
    def test__max_pack_count(self):
748
1156
        """The maximum pack count is a function of the number of revisions."""
776
1184
        repo = self.make_repository('.', format=format)
777
1185
        packs = repo._pack_collection
778
1186
        self.assertEqual([0], packs.pack_distribution(0))
779
 
 
780
 
    def test_ensure_loaded_unlocked(self):
781
 
        format = self.get_format()
782
 
        repo = self.make_repository('.', format=format)
783
 
        self.assertRaises(errors.ObjectNotLocked,
784
 
                          repo._pack_collection.ensure_loaded)
785
 
 
 
1187
        
786
1188
    def test_pack_distribution_one_to_nine(self):
787
1189
        format = self.get_format()
788
1190
        repo = self.make_repository('.', format=format)
901
1303
        name = packs.names()[0]
902
1304
        pack_1 = packs.get_pack_by_name(name)
903
1305
        # the pack should be correctly initialised
904
 
        sizes = packs._names[name]
905
 
        rev_index = GraphIndex(packs._index_transport, name + '.rix', sizes[0])
906
 
        inv_index = GraphIndex(packs._index_transport, name + '.iix', sizes[1])
907
 
        txt_index = GraphIndex(packs._index_transport, name + '.tix', sizes[2])
908
 
        sig_index = GraphIndex(packs._index_transport, name + '.six', sizes[3])
 
1306
        rev_index = GraphIndex(packs._index_transport, name + '.rix',
 
1307
            packs._names[name][0])
 
1308
        inv_index = GraphIndex(packs._index_transport, name + '.iix',
 
1309
            packs._names[name][1])
 
1310
        txt_index = GraphIndex(packs._index_transport, name + '.tix',
 
1311
            packs._names[name][2])
 
1312
        sig_index = GraphIndex(packs._index_transport, name + '.six',
 
1313
            packs._names[name][3])
909
1314
        self.assertEqual(pack_repo.ExistingPack(packs._pack_transport,
910
1315
            name, rev_index, inv_index, txt_index, sig_index), pack_1)
911
1316
        # and the same instance should be returned on successive calls.
982
1387
        self.assertEqual(20, len(pack.random_name))
983
1388
        self.assertIsInstance(pack.random_name, str)
984
1389
        self.assertIsInstance(pack.start_time, float)
985
 
 
986
 
 
987
 
class TestPacker(TestCaseWithTransport):
988
 
    """Tests for the packs repository Packer class."""
989
 
 
990
 
    # To date, this class has been factored out and nothing new added to it;
991
 
    # thus there are not yet any tests.
992
 
 
993
 
 
994
 
class TestInterDifferingSerializer(TestCaseWithTransport):
995
 
 
996
 
    def test_progress_bar(self):
997
 
        tree = self.make_branch_and_tree('tree')
998
 
        tree.commit('rev1', rev_id='rev-1')
999
 
        tree.commit('rev2', rev_id='rev-2')
1000
 
        tree.commit('rev3', rev_id='rev-3')
1001
 
        repo = self.make_repository('repo')
1002
 
        inter_repo = repository.InterDifferingSerializer(
1003
 
            tree.branch.repository, repo)
1004
 
        pb = progress.InstrumentedProgress(to_file=StringIO())
1005
 
        pb.never_throttle = True
1006
 
        inter_repo.fetch('rev-1', pb)
1007
 
        self.assertEqual('Transferring revisions', pb.last_msg)
1008
 
        self.assertEqual(1, pb.last_cnt)
1009
 
        self.assertEqual(1, pb.last_total)
1010
 
        inter_repo.fetch('rev-3', pb)
1011
 
        self.assertEqual(2, pb.last_cnt)
1012
 
        self.assertEqual(2, pb.last_total)