← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_versionedfile.py

(vila) Fix test failures blocking package builds. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/per_versionedfile.py
1
 
# Copyright (C) 2005, 2009 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# Authors:
4
4
#   Johan Rydberg <jrydberg@gnu.org>
21
21
# TODO: might be nice to create a versionedfile with some type of corruption
22
22
# considered typical and check that it can be detected/corrected.
23
23
 
 
24
from gzip import GzipFile
24
25
from itertools import chain, izip
25
26
from StringIO import StringIO
26
27
 
31
32
    knit as _mod_knit,
32
33
    osutils,
33
34
    progress,
 
35
    transport,
34
36
    ui,
35
37
    )
36
38
from bzrlib.errors import (
37
39
                           RevisionNotPresent,
38
40
                           RevisionAlreadyPresent,
39
 
                           WeaveParentMismatch
40
41
                           )
41
42
from bzrlib.knit import (
42
43
    cleanup_pack_knit,
43
44
    make_file_factory,
44
45
    make_pack_factory,
45
 
    KnitAnnotateFactory,
46
 
    KnitPlainFactory,
47
46
    )
48
47
from bzrlib.tests import (
49
48
    TestCase,
50
49
    TestCaseWithMemoryTransport,
51
50
    TestNotApplicable,
52
51
    TestSkipped,
53
 
    condition_isinstance,
54
 
    split_suite_by_condition,
55
 
    multiply_tests,
56
52
    )
57
53
from bzrlib.tests.http_utils import TestCaseWithWebserver
58
 
from bzrlib.trace import mutter
59
 
from bzrlib.transport import get_transport
60
54
from bzrlib.transport.memory import MemoryTransport
61
 
from bzrlib.tsort import topo_sort
62
 
from bzrlib.tuned_gzip import GzipFile
63
55
import bzrlib.versionedfile as versionedfile
64
56
from bzrlib.versionedfile import (
65
57
    ConstantMapper,
69
61
    make_versioned_files_factory,
70
62
    )
71
63
from bzrlib.weave import WeaveFile
72
 
from bzrlib.weavefile import read_weave, write_weave
73
 
 
74
 
 
75
 
def load_tests(standard_tests, module, loader):
76
 
    """Parameterize VersionedFiles tests for different implementations."""
77
 
    to_adapt, result = split_suite_by_condition(
78
 
        standard_tests, condition_isinstance(TestVersionedFiles))
79
 
    # We want to be sure of behaviour for:
80
 
    # weaves prefix layout (weave texts)
81
 
    # individually named weaves (weave inventories)
82
 
    # annotated knits - prefix|hash|hash-escape layout, we test the third only
83
 
    #                   as it is the most complex mapper.
84
 
    # individually named knits
85
 
    # individual no-graph knits in packs (signatures)
86
 
    # individual graph knits in packs (inventories)
87
 
    # individual graph nocompression knits in packs (revisions)
88
 
    # plain text knits in packs (texts)
89
 
    len_one_scenarios = [
90
 
        ('weave-named', {
91
 
            'cleanup':None,
92
 
            'factory':make_versioned_files_factory(WeaveFile,
93
 
                ConstantMapper('inventory')),
94
 
            'graph':True,
95
 
            'key_length':1,
96
 
            'support_partial_insertion': False,
97
 
            }),
98
 
        ('named-knit', {
99
 
            'cleanup':None,
100
 
            'factory':make_file_factory(False, ConstantMapper('revisions')),
101
 
            'graph':True,
102
 
            'key_length':1,
103
 
            'support_partial_insertion': False,
104
 
            }),
105
 
        ('named-nograph-nodelta-knit-pack', {
106
 
            'cleanup':cleanup_pack_knit,
107
 
            'factory':make_pack_factory(False, False, 1),
108
 
            'graph':False,
109
 
            'key_length':1,
110
 
            'support_partial_insertion': False,
111
 
            }),
112
 
        ('named-graph-knit-pack', {
113
 
            'cleanup':cleanup_pack_knit,
114
 
            'factory':make_pack_factory(True, True, 1),
115
 
            'graph':True,
116
 
            'key_length':1,
117
 
            'support_partial_insertion': True,
118
 
            }),
119
 
        ('named-graph-nodelta-knit-pack', {
120
 
            'cleanup':cleanup_pack_knit,
121
 
            'factory':make_pack_factory(True, False, 1),
122
 
            'graph':True,
123
 
            'key_length':1,
124
 
            'support_partial_insertion': False,
125
 
            }),
126
 
        ('groupcompress-nograph', {
127
 
            'cleanup':groupcompress.cleanup_pack_group,
128
 
            'factory':groupcompress.make_pack_factory(False, False, 1),
129
 
            'graph': False,
130
 
            'key_length':1,
131
 
            'support_partial_insertion':False,
132
 
            }),
133
 
        ]
134
 
    len_two_scenarios = [
135
 
        ('weave-prefix', {
136
 
            'cleanup':None,
137
 
            'factory':make_versioned_files_factory(WeaveFile,
138
 
                PrefixMapper()),
139
 
            'graph':True,
140
 
            'key_length':2,
141
 
            'support_partial_insertion': False,
142
 
            }),
143
 
        ('annotated-knit-escape', {
144
 
            'cleanup':None,
145
 
            'factory':make_file_factory(True, HashEscapedPrefixMapper()),
146
 
            'graph':True,
147
 
            'key_length':2,
148
 
            'support_partial_insertion': False,
149
 
            }),
150
 
        ('plain-knit-pack', {
151
 
            'cleanup':cleanup_pack_knit,
152
 
            'factory':make_pack_factory(True, True, 2),
153
 
            'graph':True,
154
 
            'key_length':2,
155
 
            'support_partial_insertion': True,
156
 
            }),
157
 
        ('groupcompress', {
158
 
            'cleanup':groupcompress.cleanup_pack_group,
159
 
            'factory':groupcompress.make_pack_factory(True, False, 1),
160
 
            'graph': True,
161
 
            'key_length':1,
162
 
            'support_partial_insertion':False,
163
 
            }),
164
 
        ]
165
 
    scenarios = len_one_scenarios + len_two_scenarios
166
 
    return multiply_tests(to_adapt, scenarios, result)
 
64
from bzrlib.weavefile import write_weave
 
65
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
66
 
 
67
 
 
68
load_tests = load_tests_apply_scenarios
167
69
 
168
70
 
169
71
def get_diamond_vf(f, trailing_eol=True, left_only=False):
734
636
        # the ordering here is to make a tree so that dumb searches have
735
637
        # more changes to muck up.
736
638
 
737
 
        class InstrumentedProgress(progress.DummyProgress):
 
639
        class InstrumentedProgress(progress.ProgressTask):
738
640
 
739
641
            def __init__(self):
740
 
 
741
 
                progress.DummyProgress.__init__(self)
 
642
                progress.ProgressTask.__init__(self)
742
643
                self.updates = []
743
644
 
744
645
            def update(self, msg=None, current=None, total=None):
850
751
        self.assertEquals(('references_ghost', 'line_c\n'), origins[2])
851
752
 
852
753
    def test_readonly_mode(self):
853
 
        transport = get_transport(self.get_url('.'))
 
754
        t = self.get_transport()
854
755
        factory = self.get_factory()
855
 
        vf = factory('id', transport, 0777, create=True, access_mode='w')
856
 
        vf = factory('id', transport, access_mode='r')
 
756
        vf = factory('id', t, 0777, create=True, access_mode='w')
 
757
        vf = factory('id', t, access_mode='r')
857
758
        self.assertRaises(errors.ReadOnlyError, vf.add_lines, 'base', [], [])
858
759
        self.assertRaises(errors.ReadOnlyError,
859
760
                          vf.add_lines_with_ghosts,
881
782
class TestWeave(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
882
783
 
883
784
    def get_file(self, name='foo'):
884
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=True,
885
 
            get_scope=self.get_transaction)
 
785
        return WeaveFile(name, self.get_transport(),
 
786
                         create=True,
 
787
                         get_scope=self.get_transaction)
886
788
 
887
789
    def get_file_corrupted_text(self):
888
 
        w = WeaveFile('foo', get_transport(self.get_url('.')), create=True,
889
 
            get_scope=self.get_transaction)
 
790
        w = WeaveFile('foo', self.get_transport(),
 
791
                      create=True,
 
792
                      get_scope=self.get_transaction)
890
793
        w.add_lines('v1', [], ['hello\n'])
891
794
        w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
892
795
 
920
823
        return w
921
824
 
922
825
    def reopen_file(self, name='foo', create=False):
923
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=create,
924
 
            get_scope=self.get_transaction)
 
826
        return WeaveFile(name, self.get_transport(),
 
827
                         create=create,
 
828
                         get_scope=self.get_transaction)
925
829
 
926
830
    def test_no_implicit_create(self):
927
831
        self.assertRaises(errors.NoSuchFile,
928
832
                          WeaveFile,
929
833
                          'foo',
930
 
                          get_transport(self.get_url('.')),
 
834
                          self.get_transport(),
931
835
                          get_scope=self.get_transaction)
932
836
 
933
837
    def get_factory(self):
937
841
class TestPlanMergeVersionedFile(TestCaseWithMemoryTransport):
938
842
 
939
843
    def setUp(self):
940
 
        TestCaseWithMemoryTransport.setUp(self)
 
844
        super(TestPlanMergeVersionedFile, self).setUp()
941
845
        mapper = PrefixMapper()
942
846
        factory = make_file_factory(True, mapper)
943
847
        self.vf1 = factory(self.get_transport('root-1'))
1000
904
        # we should be able to read from http with a versioned file.
1001
905
        vf = self.get_file()
1002
906
        # try an empty file access
1003
 
        readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
 
907
        readonly_vf = self.get_factory()('foo',
 
908
            transport.get_transport_from_url(self.get_readonly_url('.')))
1004
909
        self.assertEqual([], readonly_vf.versions())
 
910
 
 
911
    def test_readonly_http_works_with_feeling(self):
 
912
        # we should be able to read from http with a versioned file.
 
913
        vf = self.get_file()
1005
914
        # now with feeling.
1006
915
        vf.add_lines('1', [], ['a\n'])
1007
916
        vf.add_lines('2', ['1'], ['b\n', 'a\n'])
1008
 
        readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
 
917
        readonly_vf = self.get_factory()('foo',
 
918
            transport.get_transport_from_url(self.get_readonly_url('.')))
1009
919
        self.assertEqual(['1', '2'], vf.versions())
 
920
        self.assertEqual(['1', '2'], readonly_vf.versions())
1010
921
        for version in readonly_vf.versions():
1011
922
            readonly_vf.get_lines(version)
1012
923
 
1014
925
class TestWeaveHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
1015
926
 
1016
927
    def get_file(self):
1017
 
        return WeaveFile('foo', get_transport(self.get_url('.')), create=True,
1018
 
            get_scope=self.get_transaction)
 
928
        return WeaveFile('foo', self.get_transport(),
 
929
                         create=True,
 
930
                         get_scope=self.get_transaction)
1019
931
 
1020
932
    def get_factory(self):
1021
933
        return WeaveFile
1265
1177
class TestWeaveMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1266
1178
 
1267
1179
    def get_file(self, name='foo'):
1268
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
 
1180
        return WeaveFile(name, self.get_transport(),
 
1181
                         create=True)
1269
1182
 
1270
1183
    def log_contents(self, w):
1271
1184
        self.log('weave is:')
1464
1377
class TestVersionedFiles(TestCaseWithMemoryTransport):
1465
1378
    """Tests for the multiple-file variant of VersionedFile."""
1466
1379
 
 
1380
    # We want to be sure of behaviour for:
 
1381
    # weaves prefix layout (weave texts)
 
1382
    # individually named weaves (weave inventories)
 
1383
    # annotated knits - prefix|hash|hash-escape layout, we test the third only
 
1384
    #                   as it is the most complex mapper.
 
1385
    # individually named knits
 
1386
    # individual no-graph knits in packs (signatures)
 
1387
    # individual graph knits in packs (inventories)
 
1388
    # individual graph nocompression knits in packs (revisions)
 
1389
    # plain text knits in packs (texts)
 
1390
    len_one_scenarios = [
 
1391
        ('weave-named', {
 
1392
            'cleanup':None,
 
1393
            'factory':make_versioned_files_factory(WeaveFile,
 
1394
                ConstantMapper('inventory')),
 
1395
            'graph':True,
 
1396
            'key_length':1,
 
1397
            'support_partial_insertion': False,
 
1398
            }),
 
1399
        ('named-knit', {
 
1400
            'cleanup':None,
 
1401
            'factory':make_file_factory(False, ConstantMapper('revisions')),
 
1402
            'graph':True,
 
1403
            'key_length':1,
 
1404
            'support_partial_insertion': False,
 
1405
            }),
 
1406
        ('named-nograph-nodelta-knit-pack', {
 
1407
            'cleanup':cleanup_pack_knit,
 
1408
            'factory':make_pack_factory(False, False, 1),
 
1409
            'graph':False,
 
1410
            'key_length':1,
 
1411
            'support_partial_insertion': False,
 
1412
            }),
 
1413
        ('named-graph-knit-pack', {
 
1414
            'cleanup':cleanup_pack_knit,
 
1415
            'factory':make_pack_factory(True, True, 1),
 
1416
            'graph':True,
 
1417
            'key_length':1,
 
1418
            'support_partial_insertion': True,
 
1419
            }),
 
1420
        ('named-graph-nodelta-knit-pack', {
 
1421
            'cleanup':cleanup_pack_knit,
 
1422
            'factory':make_pack_factory(True, False, 1),
 
1423
            'graph':True,
 
1424
            'key_length':1,
 
1425
            'support_partial_insertion': False,
 
1426
            }),
 
1427
        ('groupcompress-nograph', {
 
1428
            'cleanup':groupcompress.cleanup_pack_group,
 
1429
            'factory':groupcompress.make_pack_factory(False, False, 1),
 
1430
            'graph': False,
 
1431
            'key_length':1,
 
1432
            'support_partial_insertion':False,
 
1433
            }),
 
1434
        ]
 
1435
    len_two_scenarios = [
 
1436
        ('weave-prefix', {
 
1437
            'cleanup':None,
 
1438
            'factory':make_versioned_files_factory(WeaveFile,
 
1439
                PrefixMapper()),
 
1440
            'graph':True,
 
1441
            'key_length':2,
 
1442
            'support_partial_insertion': False,
 
1443
            }),
 
1444
        ('annotated-knit-escape', {
 
1445
            'cleanup':None,
 
1446
            'factory':make_file_factory(True, HashEscapedPrefixMapper()),
 
1447
            'graph':True,
 
1448
            'key_length':2,
 
1449
            'support_partial_insertion': False,
 
1450
            }),
 
1451
        ('plain-knit-pack', {
 
1452
            'cleanup':cleanup_pack_knit,
 
1453
            'factory':make_pack_factory(True, True, 2),
 
1454
            'graph':True,
 
1455
            'key_length':2,
 
1456
            'support_partial_insertion': True,
 
1457
            }),
 
1458
        ('groupcompress', {
 
1459
            'cleanup':groupcompress.cleanup_pack_group,
 
1460
            'factory':groupcompress.make_pack_factory(True, False, 1),
 
1461
            'graph': True,
 
1462
            'key_length':1,
 
1463
            'support_partial_insertion':False,
 
1464
            }),
 
1465
        ]
 
1466
 
 
1467
    scenarios = len_one_scenarios + len_two_scenarios
 
1468
 
1467
1469
    def get_versionedfiles(self, relpath='files'):
1468
1470
        transport = self.get_transport(relpath)
1469
1471
        if relpath != '.':
1470
1472
            transport.mkdir('.')
1471
1473
        files = self.factory(transport)
1472
1474
        if self.cleanup is not None:
1473
 
            self.addCleanup(lambda:self.cleanup(files))
 
1475
            self.addCleanup(self.cleanup, files)
1474
1476
        return files
1475
1477
 
1476
1478
    def get_simple_key(self, suffix):
1480
1482
        else:
1481
1483
            return ('FileA',) + (suffix,)
1482
1484
 
 
1485
    def test_add_fallback_implies_without_fallbacks(self):
 
1486
        f = self.get_versionedfiles('files')
 
1487
        if getattr(f, 'add_fallback_versioned_files', None) is None:
 
1488
            raise TestNotApplicable("%s doesn't support fallbacks"
 
1489
                                    % (f.__class__.__name__,))
 
1490
        g = self.get_versionedfiles('fallback')
 
1491
        key_a = self.get_simple_key('a')
 
1492
        g.add_lines(key_a, [], ['\n'])
 
1493
        f.add_fallback_versioned_files(g)
 
1494
        self.assertTrue(key_a in f.get_parent_map([key_a]))
 
1495
        self.assertFalse(key_a in f.without_fallbacks().get_parent_map([key_a]))
 
1496
 
1483
1497
    def test_add_lines(self):
1484
1498
        f = self.get_versionedfiles()
1485
1499
        key0 = self.get_simple_key('r0')
1581
1595
        # All texts should be output.
1582
1596
        self.assertEqual(set(keys), seen)
1583
1597
 
 
1598
    def test_clear_cache(self):
 
1599
        files = self.get_versionedfiles()
 
1600
        files.clear_cache()
 
1601
 
1584
1602
    def test_construct(self):
1585
1603
        """Each parameterised test can be constructed on a transport."""
1586
1604
        files = self.get_versionedfiles()
1757
1775
        self.assertIsInstance(kg, _mod_graph.KnownGraph)
1758
1776
        self.assertEqual([key_a, key_b, key_c], list(kg.topo_sort()))
1759
1777
 
 
1778
    def test_known_graph_with_fallbacks(self):
 
1779
        f = self.get_versionedfiles('files')
 
1780
        if not self.graph:
 
1781
            raise TestNotApplicable('ancestry info only relevant with graph.')
 
1782
        if getattr(f, 'add_fallback_versioned_files', None) is None:
 
1783
            raise TestNotApplicable("%s doesn't support fallbacks"
 
1784
                                    % (f.__class__.__name__,))
 
1785
        key_a = self.get_simple_key('a')
 
1786
        key_b = self.get_simple_key('b')
 
1787
        key_c = self.get_simple_key('c')
 
1788
        # A     only in fallback
 
1789
        # |\
 
1790
        # | B
 
1791
        # |/
 
1792
        # C
 
1793
        g = self.get_versionedfiles('fallback')
 
1794
        g.add_lines(key_a, [], ['\n'])
 
1795
        f.add_fallback_versioned_files(g)
 
1796
        f.add_lines(key_b, [key_a], ['\n'])
 
1797
        f.add_lines(key_c, [key_a, key_b], ['\n'])
 
1798
        kg = f.get_known_graph_ancestry([key_c])
 
1799
        self.assertEqual([key_a, key_b, key_c], list(kg.topo_sort()))
 
1800
 
1760
1801
    def test_get_record_stream_empty(self):
1761
1802
        """An empty stream can be requested without error."""
1762
1803
        f = self.get_versionedfiles()
2411
2452
        else:
2412
2453
            self.assertIdenticalVersionedFile(source, files)
2413
2454
 
 
2455
    def test_insert_record_stream_long_parent_chain_out_of_order(self):
 
2456
        """An out of order stream can either error or work."""
 
2457
        if not self.graph:
 
2458
            raise TestNotApplicable('ancestry info only relevant with graph.')
 
2459
        # Create a reasonably long chain of records based on each other, where
 
2460
        # most will be deltas.
 
2461
        source = self.get_versionedfiles('source')
 
2462
        parents = ()
 
2463
        keys = []
 
2464
        content = [('same same %d\n' % n) for n in range(500)]
 
2465
        for letter in 'abcdefghijklmnopqrstuvwxyz':
 
2466
            key = ('key-' + letter,)
 
2467
            if self.key_length == 2:
 
2468
                key = ('prefix',) + key
 
2469
            content.append('content for ' + letter + '\n')
 
2470
            source.add_lines(key, parents, content)
 
2471
            keys.append(key)
 
2472
            parents = (key,)
 
2473
        # Create a stream of these records, excluding the first record that the
 
2474
        # rest ultimately depend upon, and insert it into a new vf.
 
2475
        streams = []
 
2476
        for key in reversed(keys):
 
2477
            streams.append(source.get_record_stream([key], 'unordered', False))
 
2478
        deltas = chain(*streams[:-1])
 
2479
        files = self.get_versionedfiles()
 
2480
        try:
 
2481
            files.insert_record_stream(deltas)
 
2482
        except RevisionNotPresent:
 
2483
            # Must not have corrupted the file.
 
2484
            files.check()
 
2485
        else:
 
2486
            # Must only report either just the first key as a missing parent,
 
2487
            # no key as missing (for nodelta scenarios).
 
2488
            missing = set(files.get_missing_compression_parent_keys())
 
2489
            missing.discard(keys[0])
 
2490
            self.assertEqual(set(), missing)
 
2491
 
2414
2492
    def get_knit_delta_source(self):
2415
2493
        """Get a source that can produce a stream with knit delta records,
2416
2494
        regardless of this test's scenario.
2484
2562
        # the ordering here is to make a tree so that dumb searches have
2485
2563
        # more changes to muck up.
2486
2564
 
2487
 
        class InstrumentedProgress(progress.DummyProgress):
 
2565
        class InstrumentedProgress(progress.ProgressTask):
2488
2566
 
2489
2567
            def __init__(self):
2490
 
 
2491
 
                progress.DummyProgress.__init__(self)
 
2568
                progress.ProgressTask.__init__(self)
2492
2569
                self.updates = []
2493
2570
 
2494
2571
            def update(self, msg=None, current=None, total=None):
2669
2746
        return ret
2670
2747
 
2671
2748
    def setUp(self):
2672
 
        TestCase.setUp(self)
 
2749
        super(VirtualVersionedFilesTests, self).setUp()
2673
2750
        self._lines = {}
2674
2751
        self._parent_map = {}
2675
2752
        self.texts = VirtualVersionedFiles(self._get_parent_map,