← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_versionedfile.py

  • Committer: Martin Pool
  • Date: 2008-07-14 07:39:30 UTC
  • mto: This revision was merged to the branch mainline in revision 3537.
  • Revision ID: mbp@sourcefrog.net-20080714073930-z8nl2c44jal0eozs
Update test for knit.check() to expect it to recurse into fallback vfs

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_versionedfile.py
1
 
# Copyright (C) 2006-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2005 Canonical Ltd
2
2
#
3
3
# Authors:
4
4
#   Johan Rydberg <jrydberg@gnu.org>
15
15
#
16
16
# You should have received a copy of the GNU General Public License
17
17
# along with this program; if not, write to the Free Software
18
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
18
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
19
 
20
20
 
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
25
 
from itertools import chain, izip
 
24
from itertools import chain
26
25
from StringIO import StringIO
27
26
 
 
27
import bzrlib
28
28
from bzrlib import (
29
29
    errors,
30
 
    graph as _mod_graph,
31
 
    groupcompress,
32
 
    knit as _mod_knit,
33
30
    osutils,
34
31
    progress,
35
 
    transport,
36
 
    ui,
37
32
    )
38
33
from bzrlib.errors import (
39
34
                           RevisionNotPresent,
40
35
                           RevisionAlreadyPresent,
 
36
                           WeaveParentMismatch
41
37
                           )
 
38
from bzrlib import knit as _mod_knit
42
39
from bzrlib.knit import (
43
40
    cleanup_pack_knit,
44
41
    make_file_factory,
45
42
    make_pack_factory,
 
43
    KnitAnnotateFactory,
 
44
    KnitPlainFactory,
46
45
    )
 
46
from bzrlib.symbol_versioning import one_four, one_five
47
47
from bzrlib.tests import (
48
 
    TestCase,
49
48
    TestCaseWithMemoryTransport,
50
 
    TestNotApplicable,
 
49
    TestScenarioApplier,
51
50
    TestSkipped,
 
51
    condition_isinstance,
 
52
    split_suite_by_condition,
 
53
    iter_suite_tests,
52
54
    )
53
55
from bzrlib.tests.http_utils import TestCaseWithWebserver
 
56
from bzrlib.trace import mutter
 
57
from bzrlib.transport import get_transport
54
58
from bzrlib.transport.memory import MemoryTransport
 
59
from bzrlib.tsort import topo_sort
 
60
from bzrlib.tuned_gzip import GzipFile
55
61
import bzrlib.versionedfile as versionedfile
56
62
from bzrlib.versionedfile import (
57
63
    ConstantMapper,
58
64
    HashEscapedPrefixMapper,
59
65
    PrefixMapper,
60
 
    VirtualVersionedFiles,
61
66
    make_versioned_files_factory,
62
67
    )
63
68
from bzrlib.weave import WeaveFile
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
 
69
from bzrlib.weavefile import read_weave, write_weave
 
70
 
 
71
 
 
72
def load_tests(standard_tests, module, loader):
 
73
    """Parameterize VersionedFiles tests for different implementations."""
 
74
    to_adapt, result = split_suite_by_condition(
 
75
        standard_tests, condition_isinstance(TestVersionedFiles))
 
76
    len_one_adapter = TestScenarioApplier()
 
77
    len_two_adapter = TestScenarioApplier()
 
78
    # We want to be sure of behaviour for:
 
79
    # weaves prefix layout (weave texts)
 
80
    # individually named weaves (weave inventories)
 
81
    # annotated knits - prefix|hash|hash-escape layout, we test the third only
 
82
    #                   as it is the most complex mapper.
 
83
    # individually named knits
 
84
    # individual no-graph knits in packs (signatures)
 
85
    # individual graph knits in packs (inventories)
 
86
    # individual graph nocompression knits in packs (revisions)
 
87
    # plain text knits in packs (texts)
 
88
    len_one_adapter.scenarios = [
 
89
        ('weave-named', {
 
90
            'cleanup':None,
 
91
            'factory':make_versioned_files_factory(WeaveFile,
 
92
                ConstantMapper('inventory')),
 
93
            'graph':True,
 
94
            'key_length':1,
 
95
            }),
 
96
        ('named-knit', {
 
97
            'cleanup':None,
 
98
            'factory':make_file_factory(False, ConstantMapper('revisions')),
 
99
            'graph':True,
 
100
            'key_length':1,
 
101
            }),
 
102
        ('named-nograph-knit-pack', {
 
103
            'cleanup':cleanup_pack_knit,
 
104
            'factory':make_pack_factory(False, False, 1),
 
105
            'graph':False,
 
106
            'key_length':1,
 
107
            }),
 
108
        ('named-graph-knit-pack', {
 
109
            'cleanup':cleanup_pack_knit,
 
110
            'factory':make_pack_factory(True, True, 1),
 
111
            'graph':True,
 
112
            'key_length':1,
 
113
            }),
 
114
        ('named-graph-nodelta-knit-pack', {
 
115
            'cleanup':cleanup_pack_knit,
 
116
            'factory':make_pack_factory(True, False, 1),
 
117
            'graph':True,
 
118
            'key_length':1,
 
119
            }),
 
120
        ]
 
121
    len_two_adapter.scenarios = [
 
122
        ('weave-prefix', {
 
123
            'cleanup':None,
 
124
            'factory':make_versioned_files_factory(WeaveFile,
 
125
                PrefixMapper()),
 
126
            'graph':True,
 
127
            'key_length':2,
 
128
            }),
 
129
        ('annotated-knit-escape', {
 
130
            'cleanup':None,
 
131
            'factory':make_file_factory(True, HashEscapedPrefixMapper()),
 
132
            'graph':True,
 
133
            'key_length':2,
 
134
            }),
 
135
        ('plain-knit-pack', {
 
136
            'cleanup':cleanup_pack_knit,
 
137
            'factory':make_pack_factory(True, True, 2),
 
138
            'graph':True,
 
139
            'key_length':2,
 
140
            }),
 
141
        ]
 
142
    for test in iter_suite_tests(to_adapt):
 
143
        result.addTests(len_one_adapter.adapt(test))
 
144
        result.addTests(len_two_adapter.adapt(test))
 
145
    return result
69
146
 
70
147
 
71
148
def get_diamond_vf(f, trailing_eol=True, left_only=False):
72
149
    """Get a diamond graph to exercise deltas and merges.
73
 
 
 
150
    
74
151
    :param trailing_eol: If True end the last line with \n.
75
152
    """
76
153
    parents = {
97
174
 
98
175
 
99
176
def get_diamond_files(files, key_length, trailing_eol=True, left_only=False,
100
 
    nograph=False, nokeys=False):
 
177
    nograph=False):
101
178
    """Get a diamond graph to exercise deltas and merges.
102
179
 
103
180
    This creates a 5-node graph in files. If files supports 2-length keys two
104
181
    graphs are made to exercise the support for multiple ids.
105
 
 
 
182
    
106
183
    :param trailing_eol: If True end the last line with \n.
107
184
    :param key_length: The length of keys in files. Currently supports length 1
108
185
        and 2 keys.
110
187
    :param nograph: If True, do not provide parents to the add_lines calls;
111
188
        this is useful for tests that need inserted data but have graphless
112
189
        stores.
113
 
    :param nokeys: If True, pass None is as the key for all insertions.
114
 
        Currently implies nograph.
115
190
    :return: The results of the add_lines calls.
116
191
    """
117
 
    if nokeys:
118
 
        nograph = True
119
192
    if key_length == 1:
120
193
        prefixes = [()]
121
194
    else:
132
205
        else:
133
206
            result = [prefix + suffix for suffix in suffix_list]
134
207
            return result
135
 
    def get_key(suffix):
136
 
        if nokeys:
137
 
            return (None, )
138
 
        else:
139
 
            return (suffix,)
140
208
    # we loop over each key because that spreads the inserts across prefixes,
141
209
    # which is how commit operates.
142
210
    for prefix in prefixes:
143
 
        result.append(files.add_lines(prefix + get_key('origin'), (),
 
211
        result.append(files.add_lines(prefix + ('origin',), (),
144
212
            ['origin' + last_char]))
145
213
    for prefix in prefixes:
146
 
        result.append(files.add_lines(prefix + get_key('base'),
 
214
        result.append(files.add_lines(prefix + ('base',),
147
215
            get_parents([('origin',)]), ['base' + last_char]))
148
216
    for prefix in prefixes:
149
 
        result.append(files.add_lines(prefix + get_key('left'),
 
217
        result.append(files.add_lines(prefix + ('left',),
150
218
            get_parents([('base',)]),
151
219
            ['base\n', 'left' + last_char]))
152
220
    if not left_only:
153
221
        for prefix in prefixes:
154
 
            result.append(files.add_lines(prefix + get_key('right'),
 
222
            result.append(files.add_lines(prefix + ('right',),
155
223
                get_parents([('base',)]),
156
224
                ['base\n', 'right' + last_char]))
157
225
        for prefix in prefixes:
158
 
            result.append(files.add_lines(prefix + get_key('merged'),
 
226
            result.append(files.add_lines(prefix + ('merged',),
159
227
                get_parents([('left',), ('right',)]),
160
228
                ['base\n', 'left\n', 'right\n', 'merged' + last_char]))
161
229
    return result
182
250
            versions = f.versions()
183
251
            self.assertTrue('r0' in versions)
184
252
            self.assertTrue('r1' in versions)
185
 
            self.assertEqual(f.get_lines('r0'), ['a\n', 'b\n'])
186
 
            self.assertEqual(f.get_text('r0'), 'a\nb\n')
187
 
            self.assertEqual(f.get_lines('r1'), ['b\n', 'c\n'])
 
253
            self.assertEquals(f.get_lines('r0'), ['a\n', 'b\n'])
 
254
            self.assertEquals(f.get_text('r0'), 'a\nb\n')
 
255
            self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
188
256
            self.assertEqual(2, len(f))
189
257
            self.assertEqual(2, f.num_versions())
190
 
 
 
258
    
191
259
            self.assertRaises(RevisionNotPresent,
192
260
                f.add_lines, 'r2', ['foo'], [])
193
261
            self.assertRaises(RevisionAlreadyPresent,
216
284
            self.assertTrue('r0' in versions)
217
285
            self.assertTrue('r1' in versions)
218
286
            self.assertTrue('r2' in versions)
219
 
            self.assertEqual(f.get_lines('r0'), ['a\n', 'b\n'])
220
 
            self.assertEqual(f.get_lines('r1'), ['b\n', 'c\n'])
221
 
            self.assertEqual(f.get_lines('r2'), ['c\n', 'd\n'])
 
287
            self.assertEquals(f.get_lines('r0'), ['a\n', 'b\n'])
 
288
            self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
 
289
            self.assertEquals(f.get_lines('r2'), ['c\n', 'd\n'])
222
290
            self.assertEqual(3, f.num_versions())
223
291
            origins = f.annotate('r1')
224
 
            self.assertEqual(origins[0][0], 'r0')
225
 
            self.assertEqual(origins[1][0], 'r1')
 
292
            self.assertEquals(origins[0][0], 'r0')
 
293
            self.assertEquals(origins[1][0], 'r1')
226
294
            origins = f.annotate('r2')
227
 
            self.assertEqual(origins[0][0], 'r1')
228
 
            self.assertEqual(origins[1][0], 'r2')
 
295
            self.assertEquals(origins[0][0], 'r1')
 
296
            self.assertEquals(origins[1][0], 'r2')
229
297
 
230
298
        verify_file(f)
231
299
        f = self.reopen_file()
232
300
        verify_file(f)
233
301
 
234
302
    def test_add_unicode_content(self):
235
 
        # unicode content is not permitted in versioned files.
 
303
        # unicode content is not permitted in versioned files. 
236
304
        # versioned files version sequences of bytes only.
237
305
        vf = self.get_file()
238
306
        self.assertRaises(errors.BzrBadParameterUnicode,
261
329
    def test_inline_newline_throws(self):
262
330
        # \r characters are not permitted in lines being added
263
331
        vf = self.get_file()
264
 
        self.assertRaises(errors.BzrBadParameterContainsNewline,
 
332
        self.assertRaises(errors.BzrBadParameterContainsNewline, 
265
333
            vf.add_lines, 'a', [], ['a\n\n'])
266
334
        self.assertRaises(
267
335
            (errors.BzrBadParameterContainsNewline, NotImplementedError),
466
534
        f.add_lines('noeolbase', [], ['line'])
467
535
        # noeol preceeding its leftmost parent in the output:
468
536
        # this is done by making it a merge of two parents with no common
469
 
        # anestry: noeolbase and noeol with the
 
537
        # anestry: noeolbase and noeol with the 
470
538
        # later-inserted parent the leftmost.
471
539
        f.add_lines('eolbeforefirstparent', ['noeolbase', 'noeol'], ['line'])
472
540
        # two identical eol texts
553
621
        self._transaction = 'after'
554
622
        self.assertRaises(errors.OutSideTransaction, f.add_lines, '', [], [])
555
623
        self.assertRaises(errors.OutSideTransaction, f.add_lines_with_ghosts, '', [], [])
556
 
 
 
624
        
557
625
    def test_copy_to(self):
558
626
        f = self.get_file()
559
627
        f.add_lines('0', [], ['a\n'])
595
663
        f.add_lines('r0', [], ['a\n', 'b\n'])
596
664
        f.add_lines('r1', ['r0'], ['c\n', 'b\n'])
597
665
        origins = f.annotate('r1')
598
 
        self.assertEqual(origins[0][0], 'r1')
599
 
        self.assertEqual(origins[1][0], 'r0')
 
666
        self.assertEquals(origins[0][0], 'r1')
 
667
        self.assertEquals(origins[1][0], 'r0')
600
668
 
601
669
        self.assertRaises(RevisionNotPresent,
602
670
            f.annotate, 'foo')
632
700
 
633
701
    def test_iter_lines_added_or_present_in_versions(self):
634
702
        # test that we get at least an equalset of the lines added by
635
 
        # versions in the weave
 
703
        # versions in the weave 
636
704
        # the ordering here is to make a tree so that dumb searches have
637
705
        # more changes to muck up.
638
706
 
639
 
        class InstrumentedProgress(progress.ProgressTask):
 
707
        class InstrumentedProgress(progress.DummyProgress):
640
708
 
641
709
            def __init__(self):
642
 
                progress.ProgressTask.__init__(self)
 
710
 
 
711
                progress.DummyProgress.__init__(self)
643
712
                self.updates = []
644
713
 
645
714
            def update(self, msg=None, current=None, total=None):
671
740
                self.assertEqual(expected, progress.updates)
672
741
            return lines
673
742
        lines = iter_with_versions(['child', 'otherchild'],
674
 
                                   [('Walking content', 0, 2),
675
 
                                    ('Walking content', 1, 2),
676
 
                                    ('Walking content', 2, 2)])
 
743
                                   [('Walking content.', 0, 2),
 
744
                                    ('Walking content.', 1, 2),
 
745
                                    ('Walking content.', 2, 2)])
677
746
        # we must see child and otherchild
678
747
        self.assertTrue(lines[('child\n', 'child')] > 0)
679
748
        self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
680
749
        # we dont care if we got more than that.
681
 
 
 
750
        
682
751
        # test all lines
683
 
        lines = iter_with_versions(None, [('Walking content', 0, 5),
684
 
                                          ('Walking content', 1, 5),
685
 
                                          ('Walking content', 2, 5),
686
 
                                          ('Walking content', 3, 5),
687
 
                                          ('Walking content', 4, 5),
688
 
                                          ('Walking content', 5, 5)])
 
752
        lines = iter_with_versions(None, [('Walking content.', 0, 5),
 
753
                                          ('Walking content.', 1, 5),
 
754
                                          ('Walking content.', 2, 5),
 
755
                                          ('Walking content.', 3, 5),
 
756
                                          ('Walking content.', 4, 5),
 
757
                                          ('Walking content.', 5, 5)])
689
758
        # all lines must be seen at least once
690
759
        self.assertTrue(lines[('base\n', 'base')] > 0)
691
760
        self.assertTrue(lines[('lancestor\n', 'lancestor')] > 0)
746
815
                                 ['base', 'a_ghost'],
747
816
                                 ['line\n', 'line_b\n', 'line_c\n'])
748
817
        origins = vf.annotate('references_ghost')
749
 
        self.assertEqual(('base', 'line\n'), origins[0])
750
 
        self.assertEqual(('base', 'line_b\n'), origins[1])
751
 
        self.assertEqual(('references_ghost', 'line_c\n'), origins[2])
 
818
        self.assertEquals(('base', 'line\n'), origins[0])
 
819
        self.assertEquals(('base', 'line_b\n'), origins[1])
 
820
        self.assertEquals(('references_ghost', 'line_c\n'), origins[2])
752
821
 
753
822
    def test_readonly_mode(self):
754
 
        t = self.get_transport()
 
823
        transport = get_transport(self.get_url('.'))
755
824
        factory = self.get_factory()
756
 
        vf = factory('id', t, 0777, create=True, access_mode='w')
757
 
        vf = factory('id', t, access_mode='r')
 
825
        vf = factory('id', transport, 0777, create=True, access_mode='w')
 
826
        vf = factory('id', transport, access_mode='r')
758
827
        self.assertRaises(errors.ReadOnlyError, vf.add_lines, 'base', [], [])
759
828
        self.assertRaises(errors.ReadOnlyError,
760
829
                          vf.add_lines_with_ghosts,
761
830
                          'base',
762
831
                          [],
763
832
                          [])
764
 
 
 
833
    
765
834
    def test_get_sha1s(self):
766
835
        # check the sha1 data is available
767
836
        vf = self.get_file()
777
846
            'b': '3f786850e387550fdab836ed7e6dc881de23001b',
778
847
            },
779
848
            vf.get_sha1s(['a', 'c', 'b']))
780
 
 
 
849
        
781
850
 
782
851
class TestWeave(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
783
852
 
784
853
    def get_file(self, name='foo'):
785
 
        return WeaveFile(name, self.get_transport(),
786
 
                         create=True,
787
 
                         get_scope=self.get_transaction)
 
854
        return WeaveFile(name, get_transport(self.get_url('.')), create=True,
 
855
            get_scope=self.get_transaction)
788
856
 
789
857
    def get_file_corrupted_text(self):
790
 
        w = WeaveFile('foo', self.get_transport(),
791
 
                      create=True,
792
 
                      get_scope=self.get_transaction)
 
858
        w = WeaveFile('foo', get_transport(self.get_url('.')), create=True,
 
859
            get_scope=self.get_transaction)
793
860
        w.add_lines('v1', [], ['hello\n'])
794
861
        w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
795
 
 
 
862
        
796
863
        # We are going to invasively corrupt the text
797
864
        # Make sure the internals of weave are the same
798
865
        self.assertEqual([('{', 0)
802
869
                        , 'there\n'
803
870
                        , ('}', None)
804
871
                        ], w._weave)
805
 
 
 
872
        
806
873
        self.assertEqual(['f572d396fae9206628714fb2ce00f72e94f2258f'
807
874
                        , '90f265c6e75f1c8f9ab76dcf85528352c5f215ef'
808
875
                        ], w._sha1s)
809
876
        w.check()
810
 
 
 
877
        
811
878
        # Corrupted
812
879
        w._weave[4] = 'There\n'
813
880
        return w
817
884
        # Corrected
818
885
        w._weave[4] = 'there\n'
819
886
        self.assertEqual('hello\nthere\n', w.get_text('v2'))
820
 
 
 
887
        
821
888
        #Invalid checksum, first digit changed
822
889
        w._sha1s[1] =  'f0f265c6e75f1c8f9ab76dcf85528352c5f215ef'
823
890
        return w
824
891
 
825
892
    def reopen_file(self, name='foo', create=False):
826
 
        return WeaveFile(name, self.get_transport(),
827
 
                         create=create,
828
 
                         get_scope=self.get_transaction)
 
893
        return WeaveFile(name, get_transport(self.get_url('.')), create=create,
 
894
            get_scope=self.get_transaction)
829
895
 
830
896
    def test_no_implicit_create(self):
831
897
        self.assertRaises(errors.NoSuchFile,
832
898
                          WeaveFile,
833
899
                          'foo',
834
 
                          self.get_transport(),
 
900
                          get_transport(self.get_url('.')),
835
901
                          get_scope=self.get_transaction)
836
902
 
837
903
    def get_factory(self):
841
907
class TestPlanMergeVersionedFile(TestCaseWithMemoryTransport):
842
908
 
843
909
    def setUp(self):
844
 
        super(TestPlanMergeVersionedFile, self).setUp()
 
910
        TestCaseWithMemoryTransport.setUp(self)
845
911
        mapper = PrefixMapper()
846
912
        factory = make_file_factory(True, mapper)
847
913
        self.vf1 = factory(self.get_transport('root-1'))
904
970
        # we should be able to read from http with a versioned file.
905
971
        vf = self.get_file()
906
972
        # try an empty file access
907
 
        readonly_vf = self.get_factory()('foo',
908
 
            transport.get_transport_from_url(self.get_readonly_url('.')))
 
973
        readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
909
974
        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()
914
975
        # now with feeling.
915
976
        vf.add_lines('1', [], ['a\n'])
916
977
        vf.add_lines('2', ['1'], ['b\n', 'a\n'])
917
 
        readonly_vf = self.get_factory()('foo',
918
 
            transport.get_transport_from_url(self.get_readonly_url('.')))
 
978
        readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
919
979
        self.assertEqual(['1', '2'], vf.versions())
920
 
        self.assertEqual(['1', '2'], readonly_vf.versions())
921
980
        for version in readonly_vf.versions():
922
981
            readonly_vf.get_lines(version)
923
982
 
925
984
class TestWeaveHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
926
985
 
927
986
    def get_file(self):
928
 
        return WeaveFile('foo', self.get_transport(),
929
 
                         create=True,
930
 
                         get_scope=self.get_transaction)
 
987
        return WeaveFile('foo', get_transport(self.get_url('.')), create=True,
 
988
            get_scope=self.get_transaction)
931
989
 
932
990
    def get_factory(self):
933
991
        return WeaveFile
941
999
 
942
1000
        def addcrlf(x):
943
1001
            return x + '\n'
944
 
 
 
1002
        
945
1003
        w = self.get_file()
946
1004
        w.add_lines('text0', [], map(addcrlf, base))
947
1005
        w.add_lines('text1', ['text0'], map(addcrlf, a))
963
1021
 
964
1022
        mp = map(addcrlf, mp)
965
1023
        self.assertEqual(mt.readlines(), mp)
966
 
 
967
 
 
 
1024
        
 
1025
        
968
1026
    def testOneInsert(self):
969
1027
        self.doMerge([],
970
1028
                     ['aa'],
988
1046
                     ['aaa', 'xxx', 'yyy', 'bbb'],
989
1047
                     ['aaa', 'xxx', 'bbb'], self.overlappedInsertExpected)
990
1048
 
991
 
        # really it ought to reduce this to
 
1049
        # really it ought to reduce this to 
992
1050
        # ['aaa', 'xxx', 'yyy', 'bbb']
993
1051
 
994
1052
 
996
1054
        self.doMerge(['aaa'],
997
1055
                     ['xxx'],
998
1056
                     ['yyy', 'zzz'],
999
 
                     ['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz',
 
1057
                     ['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz', 
1000
1058
                      '>>>>>>> '])
1001
1059
 
1002
1060
    def testNonClashInsert1(self):
1003
1061
        self.doMerge(['aaa'],
1004
1062
                     ['xxx', 'aaa'],
1005
1063
                     ['yyy', 'zzz'],
1006
 
                     ['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz',
 
1064
                     ['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz', 
1007
1065
                      '>>>>>>> '])
1008
1066
 
1009
1067
    def testNonClashInsert2(self):
1023
1081
        #######################################
1024
1082
        # skippd, not working yet
1025
1083
        return
1026
 
 
 
1084
        
1027
1085
        self.doMerge(['aaa', 'bbb', 'ccc'],
1028
1086
                     ['aaa', 'ddd', 'ccc'],
1029
1087
                     ['aaa', 'ccc'],
1066
1124
            """
1067
1125
        result = """\
1068
1126
            line 1
1069
 
<<<<<<<\x20
1070
 
            line 2
1071
 
=======
1072
 
>>>>>>>\x20
1073
1127
            """
1074
1128
        self._test_merge_from_strings(base, a, b, result)
1075
1129
 
1076
1130
    def test_deletion_overlap(self):
1077
1131
        """Delete overlapping regions with no other conflict.
1078
1132
 
1079
 
        Arguably it'd be better to treat these as agreement, rather than
 
1133
        Arguably it'd be better to treat these as agreement, rather than 
1080
1134
        conflict, but for now conflict is safer.
1081
1135
        """
1082
1136
        base = """\
1098
1152
            """
1099
1153
        result = """\
1100
1154
            start context
1101
 
<<<<<<<\x20
 
1155
<<<<<<< 
1102
1156
            int a() {}
1103
1157
=======
1104
1158
            int c() {}
1105
 
>>>>>>>\x20
 
1159
>>>>>>> 
1106
1160
            end context
1107
1161
            """
1108
1162
        self._test_merge_from_strings(base, a, b, result)
1134
1188
 
1135
1189
    def test_sync_on_deletion(self):
1136
1190
        """Specific case of merge where we can synchronize incorrectly.
1137
 
 
 
1191
        
1138
1192
        A previous version of the weave merge concluded that the two versions
1139
1193
        agreed on deleting line 2, and this could be a synchronization point.
1140
 
        Line 1 was then considered in isolation, and thought to be deleted on
 
1194
        Line 1 was then considered in isolation, and thought to be deleted on 
1141
1195
        both sides.
1142
1196
 
1143
1197
        It's better to consider the whole thing as a disagreement region.
1162
1216
            """
1163
1217
        result = """\
1164
1218
            start context
1165
 
<<<<<<<\x20
 
1219
<<<<<<< 
1166
1220
            base line 1
1167
1221
            a's replacement line 2
1168
1222
=======
1169
1223
            b replaces
1170
1224
            both lines
1171
 
>>>>>>>\x20
 
1225
>>>>>>> 
1172
1226
            end context
1173
1227
            """
1174
1228
        self._test_merge_from_strings(base, a, b, result)
1177
1231
class TestWeaveMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1178
1232
 
1179
1233
    def get_file(self, name='foo'):
1180
 
        return WeaveFile(name, self.get_transport(),
1181
 
                         create=True)
 
1234
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
1182
1235
 
1183
1236
    def log_contents(self, w):
1184
1237
        self.log('weave is:')
1186
1239
        write_weave(w, tmpf)
1187
1240
        self.log(tmpf.getvalue())
1188
1241
 
1189
 
    overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======',
 
1242
    overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======', 
1190
1243
                                'xxx', '>>>>>>> ', 'bbb']
1191
1244
 
1192
1245
 
1224
1277
        # origin is a fulltext
1225
1278
        entries = f.get_record_stream([('origin',)], 'unordered', False)
1226
1279
        base = entries.next()
1227
 
        ft_data = ft_adapter.get_bytes(base)
 
1280
        ft_data = ft_adapter.get_bytes(base, base.get_bytes_as(base.storage_kind))
1228
1281
        # merged is both a delta and multiple parents.
1229
1282
        entries = f.get_record_stream([('merged',)], 'unordered', False)
1230
1283
        merged = entries.next()
1231
 
        delta_data = delta_adapter.get_bytes(merged)
 
1284
        delta_data = delta_adapter.get_bytes(merged,
 
1285
            merged.get_bytes_as(merged.storage_kind))
1232
1286
        return ft_data, delta_data
1233
1287
 
1234
1288
    def test_deannotation_noeol(self):
1301
1355
 
1302
1356
    def test_unannotated_to_fulltext(self):
1303
1357
        """Test adapting unannotated knits to full texts.
1304
 
 
 
1358
        
1305
1359
        This is used for -> weaves, and for -> annotated knits.
1306
1360
        """
1307
1361
        # we need a full text, and a delta
1320
1374
 
1321
1375
    def test_unannotated_to_fulltext_no_eol(self):
1322
1376
        """Test adapting unannotated knits to full texts.
1323
 
 
 
1377
        
1324
1378
        This is used for -> weaves, and for -> annotated knits.
1325
1379
        """
1326
1380
        # we need a full text, and a delta
1377
1431
class TestVersionedFiles(TestCaseWithMemoryTransport):
1378
1432
    """Tests for the multiple-file variant of VersionedFile."""
1379
1433
 
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
 
 
1469
1434
    def get_versionedfiles(self, relpath='files'):
1470
1435
        transport = self.get_transport(relpath)
1471
1436
        if relpath != '.':
1472
1437
            transport.mkdir('.')
1473
1438
        files = self.factory(transport)
1474
1439
        if self.cleanup is not None:
1475
 
            self.addCleanup(self.cleanup, files)
 
1440
            self.addCleanup(lambda:self.cleanup(files))
1476
1441
        return files
1477
1442
 
1478
 
    def get_simple_key(self, suffix):
1479
 
        """Return a key for the object under test."""
1480
 
        if self.key_length == 1:
1481
 
            return (suffix,)
1482
 
        else:
1483
 
            return ('FileA',) + (suffix,)
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
 
 
1497
 
    def test_add_lines(self):
1498
 
        f = self.get_versionedfiles()
1499
 
        key0 = self.get_simple_key('r0')
1500
 
        key1 = self.get_simple_key('r1')
1501
 
        key2 = self.get_simple_key('r2')
1502
 
        keyf = self.get_simple_key('foo')
1503
 
        f.add_lines(key0, [], ['a\n', 'b\n'])
1504
 
        if self.graph:
1505
 
            f.add_lines(key1, [key0], ['b\n', 'c\n'])
1506
 
        else:
1507
 
            f.add_lines(key1, [], ['b\n', 'c\n'])
1508
 
        keys = f.keys()
1509
 
        self.assertTrue(key0 in keys)
1510
 
        self.assertTrue(key1 in keys)
1511
 
        records = []
1512
 
        for record in f.get_record_stream([key0, key1], 'unordered', True):
1513
 
            records.append((record.key, record.get_bytes_as('fulltext')))
1514
 
        records.sort()
1515
 
        self.assertEqual([(key0, 'a\nb\n'), (key1, 'b\nc\n')], records)
1516
 
 
1517
 
    def test__add_text(self):
1518
 
        f = self.get_versionedfiles()
1519
 
        key0 = self.get_simple_key('r0')
1520
 
        key1 = self.get_simple_key('r1')
1521
 
        key2 = self.get_simple_key('r2')
1522
 
        keyf = self.get_simple_key('foo')
1523
 
        f._add_text(key0, [], 'a\nb\n')
1524
 
        if self.graph:
1525
 
            f._add_text(key1, [key0], 'b\nc\n')
1526
 
        else:
1527
 
            f._add_text(key1, [], 'b\nc\n')
1528
 
        keys = f.keys()
1529
 
        self.assertTrue(key0 in keys)
1530
 
        self.assertTrue(key1 in keys)
1531
 
        records = []
1532
 
        for record in f.get_record_stream([key0, key1], 'unordered', True):
1533
 
            records.append((record.key, record.get_bytes_as('fulltext')))
1534
 
        records.sort()
1535
 
        self.assertEqual([(key0, 'a\nb\n'), (key1, 'b\nc\n')], records)
1536
 
 
1537
1443
    def test_annotate(self):
1538
1444
        files = self.get_versionedfiles()
1539
1445
        self.get_diamond_files(files)
1573
1479
        self.assertRaises(RevisionNotPresent,
1574
1480
            files.annotate, prefix + ('missing-key',))
1575
1481
 
1576
 
    def test_check_no_parameters(self):
1577
 
        files = self.get_versionedfiles()
1578
 
 
1579
 
    def test_check_progressbar_parameter(self):
1580
 
        """A progress bar can be supplied because check can be a generator."""
1581
 
        pb = ui.ui_factory.nested_progress_bar()
1582
 
        self.addCleanup(pb.finished)
1583
 
        files = self.get_versionedfiles()
1584
 
        files.check(progress_bar=pb)
1585
 
 
1586
 
    def test_check_with_keys_becomes_generator(self):
1587
 
        files = self.get_versionedfiles()
1588
 
        self.get_diamond_files(files)
1589
 
        keys = files.keys()
1590
 
        entries = files.check(keys=keys)
1591
 
        seen = set()
1592
 
        # Texts output should be fulltexts.
1593
 
        self.capture_stream(files, entries, seen.add,
1594
 
            files.get_parent_map(keys), require_fulltext=True)
1595
 
        # All texts should be output.
1596
 
        self.assertEqual(set(keys), seen)
1597
 
 
1598
 
    def test_clear_cache(self):
1599
 
        files = self.get_versionedfiles()
1600
 
        files.clear_cache()
1601
 
 
1602
1482
    def test_construct(self):
1603
1483
        """Each parameterised test can be constructed on a transport."""
1604
1484
        files = self.get_versionedfiles()
1605
1485
 
1606
 
    def get_diamond_files(self, files, trailing_eol=True, left_only=False,
1607
 
        nokeys=False):
 
1486
    def get_diamond_files(self, files, trailing_eol=True, left_only=False):
1608
1487
        return get_diamond_files(files, self.key_length,
1609
1488
            trailing_eol=trailing_eol, nograph=not self.graph,
1610
 
            left_only=left_only, nokeys=nokeys)
1611
 
 
1612
 
    def _add_content_nostoresha(self, add_lines):
1613
 
        """When nostore_sha is supplied using old content raises."""
1614
 
        vf = self.get_versionedfiles()
1615
 
        empty_text = ('a', [])
1616
 
        sample_text_nl = ('b', ["foo\n", "bar\n"])
1617
 
        sample_text_no_nl = ('c', ["foo\n", "bar"])
1618
 
        shas = []
1619
 
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
1620
 
            if add_lines:
1621
 
                sha, _, _ = vf.add_lines(self.get_simple_key(version), [],
1622
 
                                         lines)
1623
 
            else:
1624
 
                sha, _, _ = vf._add_text(self.get_simple_key(version), [],
1625
 
                                         ''.join(lines))
1626
 
            shas.append(sha)
1627
 
        # we now have a copy of all the lines in the vf.
1628
 
        for sha, (version, lines) in zip(
1629
 
            shas, (empty_text, sample_text_nl, sample_text_no_nl)):
1630
 
            new_key = self.get_simple_key(version + "2")
1631
 
            self.assertRaises(errors.ExistingContent,
1632
 
                vf.add_lines, new_key, [], lines,
1633
 
                nostore_sha=sha)
1634
 
            self.assertRaises(errors.ExistingContent,
1635
 
                vf._add_text, new_key, [], ''.join(lines),
1636
 
                nostore_sha=sha)
1637
 
            # and no new version should have been added.
1638
 
            record = vf.get_record_stream([new_key], 'unordered', True).next()
1639
 
            self.assertEqual('absent', record.storage_kind)
1640
 
 
1641
 
    def test_add_lines_nostoresha(self):
1642
 
        self._add_content_nostoresha(add_lines=True)
1643
 
 
1644
 
    def test__add_text_nostoresha(self):
1645
 
        self._add_content_nostoresha(add_lines=False)
 
1489
            left_only=left_only)
1646
1490
 
1647
1491
    def test_add_lines_return(self):
1648
1492
        files = self.get_versionedfiles()
1675
1519
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
1676
1520
                results)
1677
1521
 
1678
 
    def test_add_lines_no_key_generates_chk_key(self):
1679
 
        files = self.get_versionedfiles()
1680
 
        # save code by using the stock data insertion helper.
1681
 
        adds = self.get_diamond_files(files, nokeys=True)
1682
 
        results = []
1683
 
        # We can only validate the first 2 elements returned from add_lines.
1684
 
        for add in adds:
1685
 
            self.assertEqual(3, len(add))
1686
 
            results.append(add[:2])
1687
 
        if self.key_length == 1:
1688
 
            self.assertEqual([
1689
 
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
1690
 
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
1691
 
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
1692
 
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
1693
 
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
1694
 
                results)
1695
 
            # Check the added items got CHK keys.
1696
 
            self.assertEqual(set([
1697
 
                ('sha1:00e364d235126be43292ab09cb4686cf703ddc17',),
1698
 
                ('sha1:51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44',),
1699
 
                ('sha1:9ef09dfa9d86780bdec9219a22560c6ece8e0ef1',),
1700
 
                ('sha1:a8478686da38e370e32e42e8a0c220e33ee9132f',),
1701
 
                ('sha1:ed8bce375198ea62444dc71952b22cfc2b09226d',),
1702
 
                ]),
1703
 
                files.keys())
1704
 
        elif self.key_length == 2:
1705
 
            self.assertEqual([
1706
 
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
1707
 
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
1708
 
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
1709
 
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
1710
 
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
1711
 
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
1712
 
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
1713
 
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
1714
 
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23),
1715
 
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
1716
 
                results)
1717
 
            # Check the added items got CHK keys.
1718
 
            self.assertEqual(set([
1719
 
                ('FileA', 'sha1:00e364d235126be43292ab09cb4686cf703ddc17'),
1720
 
                ('FileA', 'sha1:51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44'),
1721
 
                ('FileA', 'sha1:9ef09dfa9d86780bdec9219a22560c6ece8e0ef1'),
1722
 
                ('FileA', 'sha1:a8478686da38e370e32e42e8a0c220e33ee9132f'),
1723
 
                ('FileA', 'sha1:ed8bce375198ea62444dc71952b22cfc2b09226d'),
1724
 
                ('FileB', 'sha1:00e364d235126be43292ab09cb4686cf703ddc17'),
1725
 
                ('FileB', 'sha1:51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44'),
1726
 
                ('FileB', 'sha1:9ef09dfa9d86780bdec9219a22560c6ece8e0ef1'),
1727
 
                ('FileB', 'sha1:a8478686da38e370e32e42e8a0c220e33ee9132f'),
1728
 
                ('FileB', 'sha1:ed8bce375198ea62444dc71952b22cfc2b09226d'),
1729
 
                ]),
1730
 
                files.keys())
1731
 
 
1732
1522
    def test_empty_lines(self):
1733
1523
        """Empty files can be stored."""
1734
1524
        f = self.get_versionedfiles()
1756
1546
            f.get_record_stream([key_b], 'unordered', True
1757
1547
                ).next().get_bytes_as('fulltext'))
1758
1548
 
1759
 
    def test_get_known_graph_ancestry(self):
1760
 
        f = self.get_versionedfiles()
1761
 
        if not self.graph:
1762
 
            raise TestNotApplicable('ancestry info only relevant with graph.')
1763
 
        key_a = self.get_simple_key('a')
1764
 
        key_b = self.get_simple_key('b')
1765
 
        key_c = self.get_simple_key('c')
1766
 
        # A
1767
 
        # |\
1768
 
        # | B
1769
 
        # |/
1770
 
        # C
1771
 
        f.add_lines(key_a, [], ['\n'])
1772
 
        f.add_lines(key_b, [key_a], ['\n'])
1773
 
        f.add_lines(key_c, [key_a, key_b], ['\n'])
1774
 
        kg = f.get_known_graph_ancestry([key_c])
1775
 
        self.assertIsInstance(kg, _mod_graph.KnownGraph)
1776
 
        self.assertEqual([key_a, key_b, key_c], list(kg.topo_sort()))
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
 
 
1801
1549
    def test_get_record_stream_empty(self):
1802
1550
        """An empty stream can be requested without error."""
1803
1551
        f = self.get_versionedfiles()
1808
1556
        """Assert that storage_kind is a valid storage_kind."""
1809
1557
        self.assertSubset([storage_kind],
1810
1558
            ['mpdiff', 'knit-annotated-ft', 'knit-annotated-delta',
1811
 
             'knit-ft', 'knit-delta', 'chunked', 'fulltext',
1812
 
             'knit-annotated-ft-gz', 'knit-annotated-delta-gz', 'knit-ft-gz',
1813
 
             'knit-delta-gz',
1814
 
             'knit-delta-closure', 'knit-delta-closure-ref',
1815
 
             'groupcompress-block', 'groupcompress-block-ref'])
 
1559
             'knit-ft', 'knit-delta', 'fulltext', 'knit-annotated-ft-gz',
 
1560
             'knit-annotated-delta-gz', 'knit-ft-gz', 'knit-delta-gz'])
1816
1561
 
1817
 
    def capture_stream(self, f, entries, on_seen, parents,
1818
 
        require_fulltext=False):
 
1562
    def capture_stream(self, f, entries, on_seen, parents):
1819
1563
        """Capture a stream for testing."""
1820
1564
        for factory in entries:
1821
1565
            on_seen(factory.key)
1822
1566
            self.assertValidStorageKind(factory.storage_kind)
1823
 
            if factory.sha1 is not None:
1824
 
                self.assertEqual(f.get_sha1s([factory.key])[factory.key],
1825
 
                    factory.sha1)
 
1567
            self.assertEqual(f.get_sha1s([factory.key])[factory.key],
 
1568
                factory.sha1)
1826
1569
            self.assertEqual(parents[factory.key], factory.parents)
1827
1570
            self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
1828
1571
                str)
1829
 
            if require_fulltext:
1830
 
                factory.get_bytes_as('fulltext')
1831
1572
 
1832
1573
    def test_get_record_stream_interface(self):
1833
1574
        """each item in a stream has to provide a regular interface."""
1840
1581
        self.capture_stream(files, entries, seen.add, parent_map)
1841
1582
        self.assertEqual(set(keys), seen)
1842
1583
 
 
1584
    def get_simple_key(self, suffix):
 
1585
        """Return a key for the object under test."""
 
1586
        if self.key_length == 1:
 
1587
            return (suffix,)
 
1588
        else:
 
1589
            return ('FileA',) + (suffix,)
 
1590
 
1843
1591
    def get_keys_and_sort_order(self):
1844
1592
        """Get diamond test keys list, and their sort ordering."""
1845
1593
        if self.key_length == 1:
1860
1608
                }
1861
1609
        return keys, sort_order
1862
1610
 
1863
 
    def get_keys_and_groupcompress_sort_order(self):
1864
 
        """Get diamond test keys list, and their groupcompress sort ordering."""
1865
 
        if self.key_length == 1:
1866
 
            keys = [('merged',), ('left',), ('right',), ('base',)]
1867
 
            sort_order = {('merged',):0, ('left',):1, ('right',):1, ('base',):2}
1868
 
        else:
1869
 
            keys = [
1870
 
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
1871
 
                ('FileA', 'base'),
1872
 
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
1873
 
                ('FileB', 'base'),
1874
 
                ]
1875
 
            sort_order = {
1876
 
                ('FileA', 'merged'):0, ('FileA', 'left'):1, ('FileA', 'right'):1,
1877
 
                ('FileA', 'base'):2,
1878
 
                ('FileB', 'merged'):3, ('FileB', 'left'):4, ('FileB', 'right'):4,
1879
 
                ('FileB', 'base'):5,
1880
 
                }
1881
 
        return keys, sort_order
1882
 
 
1883
1611
    def test_get_record_stream_interface_ordered(self):
1884
1612
        """each item in a stream has to provide a regular interface."""
1885
1613
        files = self.get_versionedfiles()
1906
1634
                [None, files.get_sha1s([factory.key])[factory.key]])
1907
1635
            self.assertEqual(parent_map[factory.key], factory.parents)
1908
1636
            # self.assertEqual(files.get_text(factory.key),
1909
 
            ft_bytes = factory.get_bytes_as('fulltext')
1910
 
            self.assertIsInstance(ft_bytes, str)
1911
 
            chunked_bytes = factory.get_bytes_as('chunked')
1912
 
            self.assertEqualDiff(ft_bytes, ''.join(chunked_bytes))
1913
 
 
1914
 
        self.assertStreamOrder(sort_order, seen, keys)
1915
 
 
1916
 
    def test_get_record_stream_interface_groupcompress(self):
1917
 
        """each item in a stream has to provide a regular interface."""
1918
 
        files = self.get_versionedfiles()
1919
 
        self.get_diamond_files(files)
1920
 
        keys, sort_order = self.get_keys_and_groupcompress_sort_order()
1921
 
        parent_map = files.get_parent_map(keys)
1922
 
        entries = files.get_record_stream(keys, 'groupcompress', False)
1923
 
        seen = []
1924
 
        self.capture_stream(files, entries, seen.append, parent_map)
 
1637
            self.assertIsInstance(factory.get_bytes_as('fulltext'), str)
 
1638
            self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
 
1639
                str)
1925
1640
        self.assertStreamOrder(sort_order, seen, keys)
1926
1641
 
1927
1642
    def assertStreamOrder(self, sort_order, seen, keys):
1960
1675
        for factory in entries:
1961
1676
            seen.add(factory.key)
1962
1677
            self.assertValidStorageKind(factory.storage_kind)
1963
 
            if factory.sha1 is not None:
1964
 
                self.assertEqual(files.get_sha1s([factory.key])[factory.key],
1965
 
                                 factory.sha1)
 
1678
            self.assertEqual(files.get_sha1s([factory.key])[factory.key],
 
1679
                factory.sha1)
1966
1680
            self.assertEqual(parent_map[factory.key], factory.parents)
1967
1681
            # currently no stream emits mpdiff
1968
1682
            self.assertRaises(errors.UnavailableRepresentation,
1990
1704
        entries = files.get_record_stream(keys, 'topological', False)
1991
1705
        self.assertAbsentRecord(files, keys, parent_map, entries)
1992
1706
 
1993
 
    def assertRecordHasContent(self, record, bytes):
1994
 
        """Assert that record has the bytes bytes."""
1995
 
        self.assertEqual(bytes, record.get_bytes_as('fulltext'))
1996
 
        self.assertEqual(bytes, ''.join(record.get_bytes_as('chunked')))
1997
 
 
1998
 
    def test_get_record_stream_native_formats_are_wire_ready_one_ft(self):
1999
 
        files = self.get_versionedfiles()
2000
 
        key = self.get_simple_key('foo')
2001
 
        files.add_lines(key, (), ['my text\n', 'content'])
2002
 
        stream = files.get_record_stream([key], 'unordered', False)
2003
 
        record = stream.next()
2004
 
        if record.storage_kind in ('chunked', 'fulltext'):
2005
 
            # chunked and fulltext representations are for direct use not wire
2006
 
            # serialisation: check they are able to be used directly. To send
2007
 
            # such records over the wire translation will be needed.
2008
 
            self.assertRecordHasContent(record, "my text\ncontent")
2009
 
        else:
2010
 
            bytes = [record.get_bytes_as(record.storage_kind)]
2011
 
            network_stream = versionedfile.NetworkRecordStream(bytes).read()
2012
 
            source_record = record
2013
 
            records = []
2014
 
            for record in network_stream:
2015
 
                records.append(record)
2016
 
                self.assertEqual(source_record.storage_kind,
2017
 
                    record.storage_kind)
2018
 
                self.assertEqual(source_record.parents, record.parents)
2019
 
                self.assertEqual(
2020
 
                    source_record.get_bytes_as(source_record.storage_kind),
2021
 
                    record.get_bytes_as(record.storage_kind))
2022
 
            self.assertEqual(1, len(records))
2023
 
 
2024
 
    def assertStreamMetaEqual(self, records, expected, stream):
2025
 
        """Assert that streams expected and stream have the same records.
2026
 
 
2027
 
        :param records: A list to collect the seen records.
2028
 
        :return: A generator of the records in stream.
2029
 
        """
2030
 
        # We make assertions during copying to catch things early for
2031
 
        # easier debugging.
2032
 
        for record, ref_record in izip(stream, expected):
2033
 
            records.append(record)
2034
 
            self.assertEqual(ref_record.key, record.key)
2035
 
            self.assertEqual(ref_record.storage_kind, record.storage_kind)
2036
 
            self.assertEqual(ref_record.parents, record.parents)
2037
 
            yield record
2038
 
 
2039
 
    def stream_to_bytes_or_skip_counter(self, skipped_records, full_texts,
2040
 
        stream):
2041
 
        """Convert a stream to a bytes iterator.
2042
 
 
2043
 
        :param skipped_records: A list with one element to increment when a
2044
 
            record is skipped.
2045
 
        :param full_texts: A dict from key->fulltext representation, for
2046
 
            checking chunked or fulltext stored records.
2047
 
        :param stream: A record_stream.
2048
 
        :return: An iterator over the bytes of each record.
2049
 
        """
2050
 
        for record in stream:
2051
 
            if record.storage_kind in ('chunked', 'fulltext'):
2052
 
                skipped_records[0] += 1
2053
 
                # check the content is correct for direct use.
2054
 
                self.assertRecordHasContent(record, full_texts[record.key])
2055
 
            else:
2056
 
                yield record.get_bytes_as(record.storage_kind)
2057
 
 
2058
 
    def test_get_record_stream_native_formats_are_wire_ready_ft_delta(self):
2059
 
        files = self.get_versionedfiles()
2060
 
        target_files = self.get_versionedfiles('target')
2061
 
        key = self.get_simple_key('ft')
2062
 
        key_delta = self.get_simple_key('delta')
2063
 
        files.add_lines(key, (), ['my text\n', 'content'])
2064
 
        if self.graph:
2065
 
            delta_parents = (key,)
2066
 
        else:
2067
 
            delta_parents = ()
2068
 
        files.add_lines(key_delta, delta_parents, ['different\n', 'content\n'])
2069
 
        local = files.get_record_stream([key, key_delta], 'unordered', False)
2070
 
        ref = files.get_record_stream([key, key_delta], 'unordered', False)
2071
 
        skipped_records = [0]
2072
 
        full_texts = {
2073
 
            key: "my text\ncontent",
2074
 
            key_delta: "different\ncontent\n",
2075
 
            }
2076
 
        byte_stream = self.stream_to_bytes_or_skip_counter(
2077
 
            skipped_records, full_texts, local)
2078
 
        network_stream = versionedfile.NetworkRecordStream(byte_stream).read()
2079
 
        records = []
2080
 
        # insert the stream from the network into a versioned files object so we can
2081
 
        # check the content was carried across correctly without doing delta
2082
 
        # inspection.
2083
 
        target_files.insert_record_stream(
2084
 
            self.assertStreamMetaEqual(records, ref, network_stream))
2085
 
        # No duplicates on the wire thank you!
2086
 
        self.assertEqual(2, len(records) + skipped_records[0])
2087
 
        if len(records):
2088
 
            # if any content was copied it all must have all been.
2089
 
            self.assertIdenticalVersionedFile(files, target_files)
2090
 
 
2091
 
    def test_get_record_stream_native_formats_are_wire_ready_delta(self):
2092
 
        # copy a delta over the wire
2093
 
        files = self.get_versionedfiles()
2094
 
        target_files = self.get_versionedfiles('target')
2095
 
        key = self.get_simple_key('ft')
2096
 
        key_delta = self.get_simple_key('delta')
2097
 
        files.add_lines(key, (), ['my text\n', 'content'])
2098
 
        if self.graph:
2099
 
            delta_parents = (key,)
2100
 
        else:
2101
 
            delta_parents = ()
2102
 
        files.add_lines(key_delta, delta_parents, ['different\n', 'content\n'])
2103
 
        # Copy the basis text across so we can reconstruct the delta during
2104
 
        # insertion into target.
2105
 
        target_files.insert_record_stream(files.get_record_stream([key],
2106
 
            'unordered', False))
2107
 
        local = files.get_record_stream([key_delta], 'unordered', False)
2108
 
        ref = files.get_record_stream([key_delta], 'unordered', False)
2109
 
        skipped_records = [0]
2110
 
        full_texts = {
2111
 
            key_delta: "different\ncontent\n",
2112
 
            }
2113
 
        byte_stream = self.stream_to_bytes_or_skip_counter(
2114
 
            skipped_records, full_texts, local)
2115
 
        network_stream = versionedfile.NetworkRecordStream(byte_stream).read()
2116
 
        records = []
2117
 
        # insert the stream from the network into a versioned files object so we can
2118
 
        # check the content was carried across correctly without doing delta
2119
 
        # inspection during check_stream.
2120
 
        target_files.insert_record_stream(
2121
 
            self.assertStreamMetaEqual(records, ref, network_stream))
2122
 
        # No duplicates on the wire thank you!
2123
 
        self.assertEqual(1, len(records) + skipped_records[0])
2124
 
        if len(records):
2125
 
            # if any content was copied it all must have all been
2126
 
            self.assertIdenticalVersionedFile(files, target_files)
2127
 
 
2128
 
    def test_get_record_stream_wire_ready_delta_closure_included(self):
2129
 
        # copy a delta over the wire with the ability to get its full text.
2130
 
        files = self.get_versionedfiles()
2131
 
        key = self.get_simple_key('ft')
2132
 
        key_delta = self.get_simple_key('delta')
2133
 
        files.add_lines(key, (), ['my text\n', 'content'])
2134
 
        if self.graph:
2135
 
            delta_parents = (key,)
2136
 
        else:
2137
 
            delta_parents = ()
2138
 
        files.add_lines(key_delta, delta_parents, ['different\n', 'content\n'])
2139
 
        local = files.get_record_stream([key_delta], 'unordered', True)
2140
 
        ref = files.get_record_stream([key_delta], 'unordered', True)
2141
 
        skipped_records = [0]
2142
 
        full_texts = {
2143
 
            key_delta: "different\ncontent\n",
2144
 
            }
2145
 
        byte_stream = self.stream_to_bytes_or_skip_counter(
2146
 
            skipped_records, full_texts, local)
2147
 
        network_stream = versionedfile.NetworkRecordStream(byte_stream).read()
2148
 
        records = []
2149
 
        # insert the stream from the network into a versioned files object so we can
2150
 
        # check the content was carried across correctly without doing delta
2151
 
        # inspection during check_stream.
2152
 
        for record in self.assertStreamMetaEqual(records, ref, network_stream):
2153
 
            # we have to be able to get the full text out:
2154
 
            self.assertRecordHasContent(record, full_texts[record.key])
2155
 
        # No duplicates on the wire thank you!
2156
 
        self.assertEqual(1, len(records) + skipped_records[0])
2157
 
 
2158
1707
    def assertAbsentRecord(self, files, keys, parents, entries):
2159
1708
        """Helper for test_get_record_stream_missing_records_are_absent."""
2160
1709
        seen = set()
2166
1715
                self.assertEqual(None, factory.parents)
2167
1716
            else:
2168
1717
                self.assertValidStorageKind(factory.storage_kind)
2169
 
                if factory.sha1 is not None:
2170
 
                    sha1 = files.get_sha1s([factory.key])[factory.key]
2171
 
                    self.assertEqual(sha1, factory.sha1)
 
1718
                self.assertEqual(files.get_sha1s([factory.key])[factory.key],
 
1719
                    factory.sha1)
2172
1720
                self.assertEqual(parents[factory.key], factory.parents)
2173
1721
                self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
2174
1722
                    str)
2208
1756
        else:
2209
1757
            return None
2210
1758
 
2211
 
    def test_get_annotator(self):
2212
 
        files = self.get_versionedfiles()
2213
 
        self.get_diamond_files(files)
2214
 
        origin_key = self.get_simple_key('origin')
2215
 
        base_key = self.get_simple_key('base')
2216
 
        left_key = self.get_simple_key('left')
2217
 
        right_key = self.get_simple_key('right')
2218
 
        merged_key = self.get_simple_key('merged')
2219
 
        # annotator = files.get_annotator()
2220
 
        # introduced full text
2221
 
        origins, lines = files.get_annotator().annotate(origin_key)
2222
 
        self.assertEqual([(origin_key,)], origins)
2223
 
        self.assertEqual(['origin\n'], lines)
2224
 
        # a delta
2225
 
        origins, lines = files.get_annotator().annotate(base_key)
2226
 
        self.assertEqual([(base_key,)], origins)
2227
 
        # a merge
2228
 
        origins, lines = files.get_annotator().annotate(merged_key)
2229
 
        if self.graph:
2230
 
            self.assertEqual([
2231
 
                (base_key,),
2232
 
                (left_key,),
2233
 
                (right_key,),
2234
 
                (merged_key,),
2235
 
                ], origins)
2236
 
        else:
2237
 
            # Without a graph everything is new.
2238
 
            self.assertEqual([
2239
 
                (merged_key,),
2240
 
                (merged_key,),
2241
 
                (merged_key,),
2242
 
                (merged_key,),
2243
 
                ], origins)
2244
 
        self.assertRaises(RevisionNotPresent,
2245
 
            files.get_annotator().annotate, self.get_simple_key('missing-key'))
2246
 
 
2247
1759
    def test_get_parent_map(self):
2248
1760
        files = self.get_versionedfiles()
2249
1761
        if self.key_length == 1:
2300
1812
            keys[4]: '9ef09dfa9d86780bdec9219a22560c6ece8e0ef1',
2301
1813
            },
2302
1814
            files.get_sha1s(keys))
2303
 
 
 
1815
        
2304
1816
    def test_insert_record_stream_empty(self):
2305
1817
        """Inserting an empty record stream should work."""
2306
1818
        files = self.get_versionedfiles()
2452
1964
        else:
2453
1965
            self.assertIdenticalVersionedFile(source, files)
2454
1966
 
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
 
 
2492
 
    def get_knit_delta_source(self):
2493
 
        """Get a source that can produce a stream with knit delta records,
2494
 
        regardless of this test's scenario.
2495
 
        """
2496
 
        mapper = self.get_mapper()
2497
 
        source_transport = self.get_transport('source')
2498
 
        source_transport.mkdir('.')
2499
 
        source = make_file_factory(False, mapper)(source_transport)
2500
 
        get_diamond_files(source, self.key_length, trailing_eol=True,
2501
 
            nograph=False, left_only=False)
2502
 
        return source
2503
 
 
2504
1967
    def test_insert_record_stream_delta_missing_basis_no_corruption(self):
2505
 
        """Insertion where a needed basis is not included notifies the caller
2506
 
        of the missing basis.  In the meantime a record missing its basis is
2507
 
        not added.
2508
 
        """
2509
 
        source = self.get_knit_delta_source()
2510
 
        keys = [self.get_simple_key('origin'), self.get_simple_key('merged')]
2511
 
        entries = source.get_record_stream(keys, 'unordered', False)
2512
 
        files = self.get_versionedfiles()
2513
 
        if self.support_partial_insertion:
2514
 
            self.assertEqual([],
2515
 
                list(files.get_missing_compression_parent_keys()))
2516
 
            files.insert_record_stream(entries)
2517
 
            missing_bases = files.get_missing_compression_parent_keys()
2518
 
            self.assertEqual(set([self.get_simple_key('left')]),
2519
 
                set(missing_bases))
2520
 
            self.assertEqual(set(keys), set(files.get_parent_map(keys)))
2521
 
        else:
2522
 
            self.assertRaises(
2523
 
                errors.RevisionNotPresent, files.insert_record_stream, entries)
2524
 
            files.check()
2525
 
 
2526
 
    def test_insert_record_stream_delta_missing_basis_can_be_added_later(self):
2527
 
        """Insertion where a needed basis is not included notifies the caller
2528
 
        of the missing basis.  That basis can be added in a second
2529
 
        insert_record_stream call that does not need to repeat records present
2530
 
        in the previous stream.  The record(s) that required that basis are
2531
 
        fully inserted once their basis is no longer missing.
2532
 
        """
2533
 
        if not self.support_partial_insertion:
2534
 
            raise TestNotApplicable(
2535
 
                'versioned file scenario does not support partial insertion')
2536
 
        source = self.get_knit_delta_source()
2537
 
        entries = source.get_record_stream([self.get_simple_key('origin'),
2538
 
            self.get_simple_key('merged')], 'unordered', False)
2539
 
        files = self.get_versionedfiles()
2540
 
        files.insert_record_stream(entries)
2541
 
        missing_bases = files.get_missing_compression_parent_keys()
2542
 
        self.assertEqual(set([self.get_simple_key('left')]),
2543
 
            set(missing_bases))
2544
 
        # 'merged' is inserted (although a commit of a write group involving
2545
 
        # this versionedfiles would fail).
2546
 
        merged_key = self.get_simple_key('merged')
2547
 
        self.assertEqual(
2548
 
            [merged_key], files.get_parent_map([merged_key]).keys())
2549
 
        # Add the full delta closure of the missing records
2550
 
        missing_entries = source.get_record_stream(
2551
 
            missing_bases, 'unordered', True)
2552
 
        files.insert_record_stream(missing_entries)
2553
 
        # Now 'merged' is fully inserted (and a commit would succeed).
2554
 
        self.assertEqual([], list(files.get_missing_compression_parent_keys()))
2555
 
        self.assertEqual(
2556
 
            [merged_key], files.get_parent_map([merged_key]).keys())
 
1968
        """Insertion where a needed basis is not included aborts safely."""
 
1969
        # We use a knit always here to be sure we are getting a binary delta.
 
1970
        mapper = self.get_mapper()
 
1971
        source_transport = self.get_transport('source')
 
1972
        source_transport.mkdir('.')
 
1973
        source = make_file_factory(False, mapper)(source_transport)
 
1974
        self.get_diamond_files(source)
 
1975
        entries = source.get_record_stream(['origin', 'merged'], 'unordered', False)
 
1976
        files = self.get_versionedfiles()
 
1977
        self.assertRaises(RevisionNotPresent, files.insert_record_stream,
 
1978
            entries)
2557
1979
        files.check()
 
1980
        self.assertEqual({}, files.get_parent_map([]))
2558
1981
 
2559
1982
    def test_iter_lines_added_or_present_in_keys(self):
2560
1983
        # test that we get at least an equalset of the lines added by
2562
1985
        # the ordering here is to make a tree so that dumb searches have
2563
1986
        # more changes to muck up.
2564
1987
 
2565
 
        class InstrumentedProgress(progress.ProgressTask):
 
1988
        class InstrumentedProgress(progress.DummyProgress):
2566
1989
 
2567
1990
            def __init__(self):
2568
 
                progress.ProgressTask.__init__(self)
 
1991
 
 
1992
                progress.DummyProgress.__init__(self)
2569
1993
                self.updates = []
2570
1994
 
2571
1995
            def update(self, msg=None, current=None, total=None):
2602
2026
            return lines
2603
2027
        lines = iter_with_keys(
2604
2028
            [self.get_simple_key('child'), self.get_simple_key('otherchild')],
2605
 
            [('Walking content', 0, 2),
2606
 
             ('Walking content', 1, 2),
2607
 
             ('Walking content', 2, 2)])
 
2029
            [('Walking content.', 0, 2),
 
2030
             ('Walking content.', 1, 2),
 
2031
             ('Walking content.', 2, 2)])
2608
2032
        # we must see child and otherchild
2609
2033
        self.assertTrue(lines[('child\n', self.get_simple_key('child'))] > 0)
2610
2034
        self.assertTrue(
2611
2035
            lines[('otherchild\n', self.get_simple_key('otherchild'))] > 0)
2612
2036
        # we dont care if we got more than that.
2613
 
 
 
2037
        
2614
2038
        # test all lines
2615
2039
        lines = iter_with_keys(files.keys(),
2616
 
            [('Walking content', 0, 5),
2617
 
             ('Walking content', 1, 5),
2618
 
             ('Walking content', 2, 5),
2619
 
             ('Walking content', 3, 5),
2620
 
             ('Walking content', 4, 5),
2621
 
             ('Walking content', 5, 5)])
 
2040
            [('Walking content.', 0, 5),
 
2041
             ('Walking content.', 1, 5),
 
2042
             ('Walking content.', 2, 5),
 
2043
             ('Walking content.', 3, 5),
 
2044
             ('Walking content.', 4, 5),
 
2045
             ('Walking content.', 5, 5)])
2622
2046
        # all lines must be seen at least once
2623
2047
        self.assertTrue(lines[('base\n', self.get_simple_key('base'))] > 0)
2624
2048
        self.assertTrue(
2657
2081
        files.add_lines(self.get_simple_key('noeolbase'), [], ['line'])
2658
2082
        # noeol preceeding its leftmost parent in the output:
2659
2083
        # this is done by making it a merge of two parents with no common
2660
 
        # anestry: noeolbase and noeol with the
 
2084
        # anestry: noeolbase and noeol with the 
2661
2085
        # later-inserted parent the leftmost.
2662
2086
        files.add_lines(self.get_simple_key('eolbeforefirstparent'),
2663
2087
            self.get_parents([self.get_simple_key('noeolbase'),
2733
2157
            key = ('foo', 'bar',)
2734
2158
        files.add_lines(key, (), [])
2735
2159
        self.assertEqual(set([key]), set(files.keys()))
2736
 
 
2737
 
 
2738
 
class VirtualVersionedFilesTests(TestCase):
2739
 
    """Basic tests for the VirtualVersionedFiles implementations."""
2740
 
 
2741
 
    def _get_parent_map(self, keys):
2742
 
        ret = {}
2743
 
        for k in keys:
2744
 
            if k in self._parent_map:
2745
 
                ret[k] = self._parent_map[k]
2746
 
        return ret
2747
 
 
2748
 
    def setUp(self):
2749
 
        super(VirtualVersionedFilesTests, self).setUp()
2750
 
        self._lines = {}
2751
 
        self._parent_map = {}
2752
 
        self.texts = VirtualVersionedFiles(self._get_parent_map,
2753
 
                                           self._lines.get)
2754
 
 
2755
 
    def test_add_lines(self):
2756
 
        self.assertRaises(NotImplementedError,
2757
 
                self.texts.add_lines, "foo", [], [])
2758
 
 
2759
 
    def test_add_mpdiffs(self):
2760
 
        self.assertRaises(NotImplementedError,
2761
 
                self.texts.add_mpdiffs, [])
2762
 
 
2763
 
    def test_check_noerrors(self):
2764
 
        self.texts.check()
2765
 
 
2766
 
    def test_insert_record_stream(self):
2767
 
        self.assertRaises(NotImplementedError, self.texts.insert_record_stream,
2768
 
                          [])
2769
 
 
2770
 
    def test_get_sha1s_nonexistent(self):
2771
 
        self.assertEqual({}, self.texts.get_sha1s([("NONEXISTENT",)]))
2772
 
 
2773
 
    def test_get_sha1s(self):
2774
 
        self._lines["key"] = ["dataline1", "dataline2"]
2775
 
        self.assertEqual({("key",): osutils.sha_strings(self._lines["key"])},
2776
 
                           self.texts.get_sha1s([("key",)]))
2777
 
 
2778
 
    def test_get_parent_map(self):
2779
 
        self._parent_map = {"G": ("A", "B")}
2780
 
        self.assertEqual({("G",): (("A",),("B",))},
2781
 
                          self.texts.get_parent_map([("G",), ("L",)]))
2782
 
 
2783
 
    def test_get_record_stream(self):
2784
 
        self._lines["A"] = ["FOO", "BAR"]
2785
 
        it = self.texts.get_record_stream([("A",)], "unordered", True)
2786
 
        record = it.next()
2787
 
        self.assertEqual("chunked", record.storage_kind)
2788
 
        self.assertEqual("FOOBAR", record.get_bytes_as("fulltext"))
2789
 
        self.assertEqual(["FOO", "BAR"], record.get_bytes_as("chunked"))
2790
 
 
2791
 
    def test_get_record_stream_absent(self):
2792
 
        it = self.texts.get_record_stream([("A",)], "unordered", True)
2793
 
        record = it.next()
2794
 
        self.assertEqual("absent", record.storage_kind)
2795
 
 
2796
 
    def test_iter_lines_added_or_present_in_keys(self):
2797
 
        self._lines["A"] = ["FOO", "BAR"]
2798
 
        self._lines["B"] = ["HEY"]
2799
 
        self._lines["C"] = ["Alberta"]
2800
 
        it = self.texts.iter_lines_added_or_present_in_keys([("A",), ("B",)])
2801
 
        self.assertEqual(sorted([("FOO", "A"), ("BAR", "A"), ("HEY", "B")]),
2802
 
            sorted(list(it)))
2803
 
 
2804
 
 
2805
 
class TestOrderingVersionedFilesDecorator(TestCaseWithMemoryTransport):
2806
 
 
2807
 
    def get_ordering_vf(self, key_priority):
2808
 
        builder = self.make_branch_builder('test')
2809
 
        builder.start_series()
2810
 
        builder.build_snapshot('A', None, [
2811
 
            ('add', ('', 'TREE_ROOT', 'directory', None))])
2812
 
        builder.build_snapshot('B', ['A'], [])
2813
 
        builder.build_snapshot('C', ['B'], [])
2814
 
        builder.build_snapshot('D', ['C'], [])
2815
 
        builder.finish_series()
2816
 
        b = builder.get_branch()
2817
 
        b.lock_read()
2818
 
        self.addCleanup(b.unlock)
2819
 
        vf = b.repository.inventories
2820
 
        return versionedfile.OrderingVersionedFilesDecorator(vf, key_priority)
2821
 
 
2822
 
    def test_get_empty(self):
2823
 
        vf = self.get_ordering_vf({})
2824
 
        self.assertEqual([], vf.calls)
2825
 
 
2826
 
    def test_get_record_stream_topological(self):
2827
 
        vf = self.get_ordering_vf({('A',): 3, ('B',): 2, ('C',): 4, ('D',): 1})
2828
 
        request_keys = [('B',), ('C',), ('D',), ('A',)]
2829
 
        keys = [r.key for r in vf.get_record_stream(request_keys,
2830
 
                                    'topological', False)]
2831
 
        # We should have gotten the keys in topological order
2832
 
        self.assertEqual([('A',), ('B',), ('C',), ('D',)], keys)
2833
 
        # And recorded that the request was made
2834
 
        self.assertEqual([('get_record_stream', request_keys, 'topological',
2835
 
                           False)], vf.calls)
2836
 
 
2837
 
    def test_get_record_stream_ordered(self):
2838
 
        vf = self.get_ordering_vf({('A',): 3, ('B',): 2, ('C',): 4, ('D',): 1})
2839
 
        request_keys = [('B',), ('C',), ('D',), ('A',)]
2840
 
        keys = [r.key for r in vf.get_record_stream(request_keys,
2841
 
                                   'unordered', False)]
2842
 
        # They should be returned based on their priority
2843
 
        self.assertEqual([('D',), ('B',), ('A',), ('C',)], keys)
2844
 
        # And the request recorded
2845
 
        self.assertEqual([('get_record_stream', request_keys, 'unordered',
2846
 
                           False)], vf.calls)
2847
 
 
2848
 
    def test_get_record_stream_implicit_order(self):
2849
 
        vf = self.get_ordering_vf({('B',): 2, ('D',): 1})
2850
 
        request_keys = [('B',), ('C',), ('D',), ('A',)]
2851
 
        keys = [r.key for r in vf.get_record_stream(request_keys,
2852
 
                                   'unordered', False)]
2853
 
        # A and C are not in the map, so they get sorted to the front. A comes
2854
 
        # before C alphabetically, so it comes back first
2855
 
        self.assertEqual([('A',), ('C',), ('D',), ('B',)], keys)
2856
 
        # And the request recorded
2857
 
        self.assertEqual([('get_record_stream', request_keys, 'unordered',
2858
 
                           False)], vf.calls)