← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_versionedfile.py

  • Committer: Martin Pool
  • Date: 2011-07-04 21:15:24 UTC
  • mto: (6034.1.1 filter-tree)
  • mto: This revision was merged to the branch mainline in revision 6035.
  • Revision ID: mbp@canonical.com-20110704211524-ilb7l6g4i3iizke7
Test exporting filtered tree to a zip (already works)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/per_versionedfile.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2006-2011 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 itertools import chain
 
24
from gzip import GzipFile
 
25
from itertools import chain, izip
25
26
from StringIO import StringIO
26
27
 
27
 
import bzrlib
28
28
from bzrlib import (
29
29
    errors,
 
30
    graph as _mod_graph,
 
31
    groupcompress,
 
32
    knit as _mod_knit,
30
33
    osutils,
31
34
    progress,
 
35
    transport,
 
36
    ui,
32
37
    )
33
38
from bzrlib.errors import (
34
39
                           RevisionNotPresent,
35
40
                           RevisionAlreadyPresent,
36
 
                           WeaveParentMismatch
37
41
                           )
38
 
from bzrlib import knit as _mod_knit
39
42
from bzrlib.knit import (
40
43
    cleanup_pack_knit,
41
44
    make_file_factory,
42
45
    make_pack_factory,
43
 
    KnitAnnotateFactory,
44
 
    KnitPlainFactory,
45
46
    )
46
 
from bzrlib.symbol_versioning import one_four, one_five
47
47
from bzrlib.tests import (
48
48
    TestCase,
49
49
    TestCaseWithMemoryTransport,
50
 
    TestScenarioApplier,
 
50
    TestNotApplicable,
51
51
    TestSkipped,
52
 
    condition_isinstance,
53
 
    split_suite_by_condition,
54
 
    iter_suite_tests,
55
52
    )
56
53
from bzrlib.tests.http_utils import TestCaseWithWebserver
57
 
from bzrlib.trace import mutter
58
 
from bzrlib.transport import get_transport
59
54
from bzrlib.transport.memory import MemoryTransport
60
 
from bzrlib.tsort import topo_sort
61
 
from bzrlib.tuned_gzip import GzipFile
62
55
import bzrlib.versionedfile as versionedfile
63
56
from bzrlib.versionedfile import (
64
57
    ConstantMapper,
68
61
    make_versioned_files_factory,
69
62
    )
70
63
from bzrlib.weave import WeaveFile
71
 
from bzrlib.weavefile import read_weave, write_weave
72
 
 
73
 
 
74
 
def load_tests(standard_tests, module, loader):
75
 
    """Parameterize VersionedFiles tests for different implementations."""
76
 
    to_adapt, result = split_suite_by_condition(
77
 
        standard_tests, condition_isinstance(TestVersionedFiles))
78
 
    len_one_adapter = TestScenarioApplier()
79
 
    len_two_adapter = TestScenarioApplier()
80
 
    # We want to be sure of behaviour for:
81
 
    # weaves prefix layout (weave texts)
82
 
    # individually named weaves (weave inventories)
83
 
    # annotated knits - prefix|hash|hash-escape layout, we test the third only
84
 
    #                   as it is the most complex mapper.
85
 
    # individually named knits
86
 
    # individual no-graph knits in packs (signatures)
87
 
    # individual graph knits in packs (inventories)
88
 
    # individual graph nocompression knits in packs (revisions)
89
 
    # plain text knits in packs (texts)
90
 
    len_one_adapter.scenarios = [
91
 
        ('weave-named', {
92
 
            'cleanup':None,
93
 
            'factory':make_versioned_files_factory(WeaveFile,
94
 
                ConstantMapper('inventory')),
95
 
            'graph':True,
96
 
            'key_length':1,
97
 
            }),
98
 
        ('named-knit', {
99
 
            'cleanup':None,
100
 
            'factory':make_file_factory(False, ConstantMapper('revisions')),
101
 
            'graph':True,
102
 
            'key_length':1,
103
 
            }),
104
 
        ('named-nograph-knit-pack', {
105
 
            'cleanup':cleanup_pack_knit,
106
 
            'factory':make_pack_factory(False, False, 1),
107
 
            'graph':False,
108
 
            'key_length':1,
109
 
            }),
110
 
        ('named-graph-knit-pack', {
111
 
            'cleanup':cleanup_pack_knit,
112
 
            'factory':make_pack_factory(True, True, 1),
113
 
            'graph':True,
114
 
            'key_length':1,
115
 
            }),
116
 
        ('named-graph-nodelta-knit-pack', {
117
 
            'cleanup':cleanup_pack_knit,
118
 
            'factory':make_pack_factory(True, False, 1),
119
 
            'graph':True,
120
 
            'key_length':1,
121
 
            }),
122
 
        ]
123
 
    len_two_adapter.scenarios = [
124
 
        ('weave-prefix', {
125
 
            'cleanup':None,
126
 
            'factory':make_versioned_files_factory(WeaveFile,
127
 
                PrefixMapper()),
128
 
            'graph':True,
129
 
            'key_length':2,
130
 
            }),
131
 
        ('annotated-knit-escape', {
132
 
            'cleanup':None,
133
 
            'factory':make_file_factory(True, HashEscapedPrefixMapper()),
134
 
            'graph':True,
135
 
            'key_length':2,
136
 
            }),
137
 
        ('plain-knit-pack', {
138
 
            'cleanup':cleanup_pack_knit,
139
 
            'factory':make_pack_factory(True, True, 2),
140
 
            'graph':True,
141
 
            'key_length':2,
142
 
            }),
143
 
        ]
144
 
    for test in iter_suite_tests(to_adapt):
145
 
        result.addTests(len_one_adapter.adapt(test))
146
 
        result.addTests(len_two_adapter.adapt(test))
147
 
    return 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
148
69
 
149
70
 
150
71
def get_diamond_vf(f, trailing_eol=True, left_only=False):
151
72
    """Get a diamond graph to exercise deltas and merges.
152
 
    
 
73
 
153
74
    :param trailing_eol: If True end the last line with \n.
154
75
    """
155
76
    parents = {
176
97
 
177
98
 
178
99
def get_diamond_files(files, key_length, trailing_eol=True, left_only=False,
179
 
    nograph=False):
 
100
    nograph=False, nokeys=False):
180
101
    """Get a diamond graph to exercise deltas and merges.
181
102
 
182
103
    This creates a 5-node graph in files. If files supports 2-length keys two
183
104
    graphs are made to exercise the support for multiple ids.
184
 
    
 
105
 
185
106
    :param trailing_eol: If True end the last line with \n.
186
107
    :param key_length: The length of keys in files. Currently supports length 1
187
108
        and 2 keys.
189
110
    :param nograph: If True, do not provide parents to the add_lines calls;
190
111
        this is useful for tests that need inserted data but have graphless
191
112
        stores.
 
113
    :param nokeys: If True, pass None is as the key for all insertions.
 
114
        Currently implies nograph.
192
115
    :return: The results of the add_lines calls.
193
116
    """
 
117
    if nokeys:
 
118
        nograph = True
194
119
    if key_length == 1:
195
120
        prefixes = [()]
196
121
    else:
207
132
        else:
208
133
            result = [prefix + suffix for suffix in suffix_list]
209
134
            return result
 
135
    def get_key(suffix):
 
136
        if nokeys:
 
137
            return (None, )
 
138
        else:
 
139
            return (suffix,)
210
140
    # we loop over each key because that spreads the inserts across prefixes,
211
141
    # which is how commit operates.
212
142
    for prefix in prefixes:
213
 
        result.append(files.add_lines(prefix + ('origin',), (),
 
143
        result.append(files.add_lines(prefix + get_key('origin'), (),
214
144
            ['origin' + last_char]))
215
145
    for prefix in prefixes:
216
 
        result.append(files.add_lines(prefix + ('base',),
 
146
        result.append(files.add_lines(prefix + get_key('base'),
217
147
            get_parents([('origin',)]), ['base' + last_char]))
218
148
    for prefix in prefixes:
219
 
        result.append(files.add_lines(prefix + ('left',),
 
149
        result.append(files.add_lines(prefix + get_key('left'),
220
150
            get_parents([('base',)]),
221
151
            ['base\n', 'left' + last_char]))
222
152
    if not left_only:
223
153
        for prefix in prefixes:
224
 
            result.append(files.add_lines(prefix + ('right',),
 
154
            result.append(files.add_lines(prefix + get_key('right'),
225
155
                get_parents([('base',)]),
226
156
                ['base\n', 'right' + last_char]))
227
157
        for prefix in prefixes:
228
 
            result.append(files.add_lines(prefix + ('merged',),
 
158
            result.append(files.add_lines(prefix + get_key('merged'),
229
159
                get_parents([('left',), ('right',)]),
230
160
                ['base\n', 'left\n', 'right\n', 'merged' + last_char]))
231
161
    return result
257
187
            self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
258
188
            self.assertEqual(2, len(f))
259
189
            self.assertEqual(2, f.num_versions())
260
 
    
 
190
 
261
191
            self.assertRaises(RevisionNotPresent,
262
192
                f.add_lines, 'r2', ['foo'], [])
263
193
            self.assertRaises(RevisionAlreadyPresent,
302
232
        verify_file(f)
303
233
 
304
234
    def test_add_unicode_content(self):
305
 
        # unicode content is not permitted in versioned files. 
 
235
        # unicode content is not permitted in versioned files.
306
236
        # versioned files version sequences of bytes only.
307
237
        vf = self.get_file()
308
238
        self.assertRaises(errors.BzrBadParameterUnicode,
331
261
    def test_inline_newline_throws(self):
332
262
        # \r characters are not permitted in lines being added
333
263
        vf = self.get_file()
334
 
        self.assertRaises(errors.BzrBadParameterContainsNewline, 
 
264
        self.assertRaises(errors.BzrBadParameterContainsNewline,
335
265
            vf.add_lines, 'a', [], ['a\n\n'])
336
266
        self.assertRaises(
337
267
            (errors.BzrBadParameterContainsNewline, NotImplementedError),
536
466
        f.add_lines('noeolbase', [], ['line'])
537
467
        # noeol preceeding its leftmost parent in the output:
538
468
        # this is done by making it a merge of two parents with no common
539
 
        # anestry: noeolbase and noeol with the 
 
469
        # anestry: noeolbase and noeol with the
540
470
        # later-inserted parent the leftmost.
541
471
        f.add_lines('eolbeforefirstparent', ['noeolbase', 'noeol'], ['line'])
542
472
        # two identical eol texts
623
553
        self._transaction = 'after'
624
554
        self.assertRaises(errors.OutSideTransaction, f.add_lines, '', [], [])
625
555
        self.assertRaises(errors.OutSideTransaction, f.add_lines_with_ghosts, '', [], [])
626
 
        
 
556
 
627
557
    def test_copy_to(self):
628
558
        f = self.get_file()
629
559
        f.add_lines('0', [], ['a\n'])
702
632
 
703
633
    def test_iter_lines_added_or_present_in_versions(self):
704
634
        # test that we get at least an equalset of the lines added by
705
 
        # versions in the weave 
 
635
        # versions in the weave
706
636
        # the ordering here is to make a tree so that dumb searches have
707
637
        # more changes to muck up.
708
638
 
709
 
        class InstrumentedProgress(progress.DummyProgress):
 
639
        class InstrumentedProgress(progress.ProgressTask):
710
640
 
711
641
            def __init__(self):
712
 
 
713
 
                progress.DummyProgress.__init__(self)
 
642
                progress.ProgressTask.__init__(self)
714
643
                self.updates = []
715
644
 
716
645
            def update(self, msg=None, current=None, total=None):
742
671
                self.assertEqual(expected, progress.updates)
743
672
            return lines
744
673
        lines = iter_with_versions(['child', 'otherchild'],
745
 
                                   [('Walking content.', 0, 2),
746
 
                                    ('Walking content.', 1, 2),
747
 
                                    ('Walking content.', 2, 2)])
 
674
                                   [('Walking content', 0, 2),
 
675
                                    ('Walking content', 1, 2),
 
676
                                    ('Walking content', 2, 2)])
748
677
        # we must see child and otherchild
749
678
        self.assertTrue(lines[('child\n', 'child')] > 0)
750
679
        self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
751
680
        # we dont care if we got more than that.
752
 
        
 
681
 
753
682
        # test all lines
754
 
        lines = iter_with_versions(None, [('Walking content.', 0, 5),
755
 
                                          ('Walking content.', 1, 5),
756
 
                                          ('Walking content.', 2, 5),
757
 
                                          ('Walking content.', 3, 5),
758
 
                                          ('Walking content.', 4, 5),
759
 
                                          ('Walking content.', 5, 5)])
 
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)])
760
689
        # all lines must be seen at least once
761
690
        self.assertTrue(lines[('base\n', 'base')] > 0)
762
691
        self.assertTrue(lines[('lancestor\n', 'lancestor')] > 0)
822
751
        self.assertEquals(('references_ghost', 'line_c\n'), origins[2])
823
752
 
824
753
    def test_readonly_mode(self):
825
 
        transport = get_transport(self.get_url('.'))
 
754
        t = self.get_transport()
826
755
        factory = self.get_factory()
827
 
        vf = factory('id', transport, 0777, create=True, access_mode='w')
828
 
        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')
829
758
        self.assertRaises(errors.ReadOnlyError, vf.add_lines, 'base', [], [])
830
759
        self.assertRaises(errors.ReadOnlyError,
831
760
                          vf.add_lines_with_ghosts,
832
761
                          'base',
833
762
                          [],
834
763
                          [])
835
 
    
 
764
 
836
765
    def test_get_sha1s(self):
837
766
        # check the sha1 data is available
838
767
        vf = self.get_file()
848
777
            'b': '3f786850e387550fdab836ed7e6dc881de23001b',
849
778
            },
850
779
            vf.get_sha1s(['a', 'c', 'b']))
851
 
        
 
780
 
852
781
 
853
782
class TestWeave(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
854
783
 
855
784
    def get_file(self, name='foo'):
856
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=True,
857
 
            get_scope=self.get_transaction)
 
785
        return WeaveFile(name, self.get_transport(),
 
786
                         create=True,
 
787
                         get_scope=self.get_transaction)
858
788
 
859
789
    def get_file_corrupted_text(self):
860
 
        w = WeaveFile('foo', get_transport(self.get_url('.')), create=True,
861
 
            get_scope=self.get_transaction)
 
790
        w = WeaveFile('foo', self.get_transport(),
 
791
                      create=True,
 
792
                      get_scope=self.get_transaction)
862
793
        w.add_lines('v1', [], ['hello\n'])
863
794
        w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
864
 
        
 
795
 
865
796
        # We are going to invasively corrupt the text
866
797
        # Make sure the internals of weave are the same
867
798
        self.assertEqual([('{', 0)
871
802
                        , 'there\n'
872
803
                        , ('}', None)
873
804
                        ], w._weave)
874
 
        
 
805
 
875
806
        self.assertEqual(['f572d396fae9206628714fb2ce00f72e94f2258f'
876
807
                        , '90f265c6e75f1c8f9ab76dcf85528352c5f215ef'
877
808
                        ], w._sha1s)
878
809
        w.check()
879
 
        
 
810
 
880
811
        # Corrupted
881
812
        w._weave[4] = 'There\n'
882
813
        return w
886
817
        # Corrected
887
818
        w._weave[4] = 'there\n'
888
819
        self.assertEqual('hello\nthere\n', w.get_text('v2'))
889
 
        
 
820
 
890
821
        #Invalid checksum, first digit changed
891
822
        w._sha1s[1] =  'f0f265c6e75f1c8f9ab76dcf85528352c5f215ef'
892
823
        return w
893
824
 
894
825
    def reopen_file(self, name='foo', create=False):
895
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=create,
896
 
            get_scope=self.get_transaction)
 
826
        return WeaveFile(name, self.get_transport(),
 
827
                         create=create,
 
828
                         get_scope=self.get_transaction)
897
829
 
898
830
    def test_no_implicit_create(self):
899
831
        self.assertRaises(errors.NoSuchFile,
900
832
                          WeaveFile,
901
833
                          'foo',
902
 
                          get_transport(self.get_url('.')),
 
834
                          self.get_transport(),
903
835
                          get_scope=self.get_transaction)
904
836
 
905
837
    def get_factory(self):
972
904
        # we should be able to read from http with a versioned file.
973
905
        vf = self.get_file()
974
906
        # try an empty file access
975
 
        readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
 
907
        readonly_vf = self.get_factory()('foo', transport.get_transport(
 
908
                self.get_readonly_url('.')))
976
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()
977
914
        # now with feeling.
978
915
        vf.add_lines('1', [], ['a\n'])
979
916
        vf.add_lines('2', ['1'], ['b\n', 'a\n'])
980
 
        readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
 
917
        readonly_vf = self.get_factory()('foo', transport.get_transport(
 
918
                self.get_readonly_url('.')))
981
919
        self.assertEqual(['1', '2'], vf.versions())
 
920
        self.assertEqual(['1', '2'], readonly_vf.versions())
982
921
        for version in readonly_vf.versions():
983
922
            readonly_vf.get_lines(version)
984
923
 
986
925
class TestWeaveHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
987
926
 
988
927
    def get_file(self):
989
 
        return WeaveFile('foo', get_transport(self.get_url('.')), create=True,
990
 
            get_scope=self.get_transaction)
 
928
        return WeaveFile('foo', self.get_transport(),
 
929
                         create=True,
 
930
                         get_scope=self.get_transaction)
991
931
 
992
932
    def get_factory(self):
993
933
        return WeaveFile
1001
941
 
1002
942
        def addcrlf(x):
1003
943
            return x + '\n'
1004
 
        
 
944
 
1005
945
        w = self.get_file()
1006
946
        w.add_lines('text0', [], map(addcrlf, base))
1007
947
        w.add_lines('text1', ['text0'], map(addcrlf, a))
1023
963
 
1024
964
        mp = map(addcrlf, mp)
1025
965
        self.assertEqual(mt.readlines(), mp)
1026
 
        
1027
 
        
 
966
 
 
967
 
1028
968
    def testOneInsert(self):
1029
969
        self.doMerge([],
1030
970
                     ['aa'],
1048
988
                     ['aaa', 'xxx', 'yyy', 'bbb'],
1049
989
                     ['aaa', 'xxx', 'bbb'], self.overlappedInsertExpected)
1050
990
 
1051
 
        # really it ought to reduce this to 
 
991
        # really it ought to reduce this to
1052
992
        # ['aaa', 'xxx', 'yyy', 'bbb']
1053
993
 
1054
994
 
1056
996
        self.doMerge(['aaa'],
1057
997
                     ['xxx'],
1058
998
                     ['yyy', 'zzz'],
1059
 
                     ['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz', 
 
999
                     ['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz',
1060
1000
                      '>>>>>>> '])
1061
1001
 
1062
1002
    def testNonClashInsert1(self):
1063
1003
        self.doMerge(['aaa'],
1064
1004
                     ['xxx', 'aaa'],
1065
1005
                     ['yyy', 'zzz'],
1066
 
                     ['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz', 
 
1006
                     ['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz',
1067
1007
                      '>>>>>>> '])
1068
1008
 
1069
1009
    def testNonClashInsert2(self):
1083
1023
        #######################################
1084
1024
        # skippd, not working yet
1085
1025
        return
1086
 
        
 
1026
 
1087
1027
        self.doMerge(['aaa', 'bbb', 'ccc'],
1088
1028
                     ['aaa', 'ddd', 'ccc'],
1089
1029
                     ['aaa', 'ccc'],
1126
1066
            """
1127
1067
        result = """\
1128
1068
            line 1
 
1069
<<<<<<<\x20
 
1070
            line 2
 
1071
=======
 
1072
>>>>>>>\x20
1129
1073
            """
1130
1074
        self._test_merge_from_strings(base, a, b, result)
1131
1075
 
1132
1076
    def test_deletion_overlap(self):
1133
1077
        """Delete overlapping regions with no other conflict.
1134
1078
 
1135
 
        Arguably it'd be better to treat these as agreement, rather than 
 
1079
        Arguably it'd be better to treat these as agreement, rather than
1136
1080
        conflict, but for now conflict is safer.
1137
1081
        """
1138
1082
        base = """\
1154
1098
            """
1155
1099
        result = """\
1156
1100
            start context
1157
 
<<<<<<< 
 
1101
<<<<<<<\x20
1158
1102
            int a() {}
1159
1103
=======
1160
1104
            int c() {}
1161
 
>>>>>>> 
 
1105
>>>>>>>\x20
1162
1106
            end context
1163
1107
            """
1164
1108
        self._test_merge_from_strings(base, a, b, result)
1190
1134
 
1191
1135
    def test_sync_on_deletion(self):
1192
1136
        """Specific case of merge where we can synchronize incorrectly.
1193
 
        
 
1137
 
1194
1138
        A previous version of the weave merge concluded that the two versions
1195
1139
        agreed on deleting line 2, and this could be a synchronization point.
1196
 
        Line 1 was then considered in isolation, and thought to be deleted on 
 
1140
        Line 1 was then considered in isolation, and thought to be deleted on
1197
1141
        both sides.
1198
1142
 
1199
1143
        It's better to consider the whole thing as a disagreement region.
1218
1162
            """
1219
1163
        result = """\
1220
1164
            start context
1221
 
<<<<<<< 
 
1165
<<<<<<<\x20
1222
1166
            base line 1
1223
1167
            a's replacement line 2
1224
1168
=======
1225
1169
            b replaces
1226
1170
            both lines
1227
 
>>>>>>> 
 
1171
>>>>>>>\x20
1228
1172
            end context
1229
1173
            """
1230
1174
        self._test_merge_from_strings(base, a, b, result)
1233
1177
class TestWeaveMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1234
1178
 
1235
1179
    def get_file(self, name='foo'):
1236
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
 
1180
        return WeaveFile(name, self.get_transport(),
 
1181
                         create=True)
1237
1182
 
1238
1183
    def log_contents(self, w):
1239
1184
        self.log('weave is:')
1241
1186
        write_weave(w, tmpf)
1242
1187
        self.log(tmpf.getvalue())
1243
1188
 
1244
 
    overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======', 
 
1189
    overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======',
1245
1190
                                'xxx', '>>>>>>> ', 'bbb']
1246
1191
 
1247
1192
 
1279
1224
        # origin is a fulltext
1280
1225
        entries = f.get_record_stream([('origin',)], 'unordered', False)
1281
1226
        base = entries.next()
1282
 
        ft_data = ft_adapter.get_bytes(base, base.get_bytes_as(base.storage_kind))
 
1227
        ft_data = ft_adapter.get_bytes(base)
1283
1228
        # merged is both a delta and multiple parents.
1284
1229
        entries = f.get_record_stream([('merged',)], 'unordered', False)
1285
1230
        merged = entries.next()
1286
 
        delta_data = delta_adapter.get_bytes(merged,
1287
 
            merged.get_bytes_as(merged.storage_kind))
 
1231
        delta_data = delta_adapter.get_bytes(merged)
1288
1232
        return ft_data, delta_data
1289
1233
 
1290
1234
    def test_deannotation_noeol(self):
1357
1301
 
1358
1302
    def test_unannotated_to_fulltext(self):
1359
1303
        """Test adapting unannotated knits to full texts.
1360
 
        
 
1304
 
1361
1305
        This is used for -> weaves, and for -> annotated knits.
1362
1306
        """
1363
1307
        # we need a full text, and a delta
1376
1320
 
1377
1321
    def test_unannotated_to_fulltext_no_eol(self):
1378
1322
        """Test adapting unannotated knits to full texts.
1379
 
        
 
1323
 
1380
1324
        This is used for -> weaves, and for -> annotated knits.
1381
1325
        """
1382
1326
        # we need a full text, and a delta
1433
1377
class TestVersionedFiles(TestCaseWithMemoryTransport):
1434
1378
    """Tests for the multiple-file variant of VersionedFile."""
1435
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
 
1436
1469
    def get_versionedfiles(self, relpath='files'):
1437
1470
        transport = self.get_transport(relpath)
1438
1471
        if relpath != '.':
1439
1472
            transport.mkdir('.')
1440
1473
        files = self.factory(transport)
1441
1474
        if self.cleanup is not None:
1442
 
            self.addCleanup(lambda:self.cleanup(files))
 
1475
            self.addCleanup(self.cleanup, files)
1443
1476
        return files
1444
1477
 
 
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
 
1445
1537
    def test_annotate(self):
1446
1538
        files = self.get_versionedfiles()
1447
1539
        self.get_diamond_files(files)
1481
1573
        self.assertRaises(RevisionNotPresent,
1482
1574
            files.annotate, prefix + ('missing-key',))
1483
1575
 
 
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
 
1484
1602
    def test_construct(self):
1485
1603
        """Each parameterised test can be constructed on a transport."""
1486
1604
        files = self.get_versionedfiles()
1487
1605
 
1488
 
    def get_diamond_files(self, files, trailing_eol=True, left_only=False):
 
1606
    def get_diamond_files(self, files, trailing_eol=True, left_only=False,
 
1607
        nokeys=False):
1489
1608
        return get_diamond_files(files, self.key_length,
1490
1609
            trailing_eol=trailing_eol, nograph=not self.graph,
1491
 
            left_only=left_only)
 
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)
1492
1646
 
1493
1647
    def test_add_lines_return(self):
1494
1648
        files = self.get_versionedfiles()
1521
1675
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
1522
1676
                results)
1523
1677
 
 
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
 
1524
1732
    def test_empty_lines(self):
1525
1733
        """Empty files can be stored."""
1526
1734
        f = self.get_versionedfiles()
1548
1756
            f.get_record_stream([key_b], 'unordered', True
1549
1757
                ).next().get_bytes_as('fulltext'))
1550
1758
 
 
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
 
1551
1801
    def test_get_record_stream_empty(self):
1552
1802
        """An empty stream can be requested without error."""
1553
1803
        f = self.get_versionedfiles()
1560
1810
            ['mpdiff', 'knit-annotated-ft', 'knit-annotated-delta',
1561
1811
             'knit-ft', 'knit-delta', 'chunked', 'fulltext',
1562
1812
             'knit-annotated-ft-gz', 'knit-annotated-delta-gz', 'knit-ft-gz',
1563
 
             'knit-delta-gz'])
 
1813
             'knit-delta-gz',
 
1814
             'knit-delta-closure', 'knit-delta-closure-ref',
 
1815
             'groupcompress-block', 'groupcompress-block-ref'])
1564
1816
 
1565
 
    def capture_stream(self, f, entries, on_seen, parents):
 
1817
    def capture_stream(self, f, entries, on_seen, parents,
 
1818
        require_fulltext=False):
1566
1819
        """Capture a stream for testing."""
1567
1820
        for factory in entries:
1568
1821
            on_seen(factory.key)
1569
1822
            self.assertValidStorageKind(factory.storage_kind)
1570
 
            self.assertEqual(f.get_sha1s([factory.key])[factory.key],
1571
 
                factory.sha1)
 
1823
            if factory.sha1 is not None:
 
1824
                self.assertEqual(f.get_sha1s([factory.key])[factory.key],
 
1825
                    factory.sha1)
1572
1826
            self.assertEqual(parents[factory.key], factory.parents)
1573
1827
            self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
1574
1828
                str)
 
1829
            if require_fulltext:
 
1830
                factory.get_bytes_as('fulltext')
1575
1831
 
1576
1832
    def test_get_record_stream_interface(self):
1577
1833
        """each item in a stream has to provide a regular interface."""
1584
1840
        self.capture_stream(files, entries, seen.add, parent_map)
1585
1841
        self.assertEqual(set(keys), seen)
1586
1842
 
1587
 
    def get_simple_key(self, suffix):
1588
 
        """Return a key for the object under test."""
1589
 
        if self.key_length == 1:
1590
 
            return (suffix,)
1591
 
        else:
1592
 
            return ('FileA',) + (suffix,)
1593
 
 
1594
1843
    def get_keys_and_sort_order(self):
1595
1844
        """Get diamond test keys list, and their sort ordering."""
1596
1845
        if self.key_length == 1:
1611
1860
                }
1612
1861
        return keys, sort_order
1613
1862
 
 
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
 
1614
1883
    def test_get_record_stream_interface_ordered(self):
1615
1884
        """each item in a stream has to provide a regular interface."""
1616
1885
        files = self.get_versionedfiles()
1644
1913
 
1645
1914
        self.assertStreamOrder(sort_order, seen, keys)
1646
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)
 
1925
        self.assertStreamOrder(sort_order, seen, keys)
 
1926
 
1647
1927
    def assertStreamOrder(self, sort_order, seen, keys):
1648
1928
        self.assertEqual(len(set(seen)), len(keys))
1649
1929
        if self.key_length == 1:
1680
1960
        for factory in entries:
1681
1961
            seen.add(factory.key)
1682
1962
            self.assertValidStorageKind(factory.storage_kind)
1683
 
            self.assertEqual(files.get_sha1s([factory.key])[factory.key],
1684
 
                factory.sha1)
 
1963
            if factory.sha1 is not None:
 
1964
                self.assertEqual(files.get_sha1s([factory.key])[factory.key],
 
1965
                                 factory.sha1)
1685
1966
            self.assertEqual(parent_map[factory.key], factory.parents)
1686
1967
            # currently no stream emits mpdiff
1687
1968
            self.assertRaises(errors.UnavailableRepresentation,
1709
1990
        entries = files.get_record_stream(keys, 'topological', False)
1710
1991
        self.assertAbsentRecord(files, keys, parent_map, entries)
1711
1992
 
 
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
 
1712
2158
    def assertAbsentRecord(self, files, keys, parents, entries):
1713
2159
        """Helper for test_get_record_stream_missing_records_are_absent."""
1714
2160
        seen = set()
1720
2166
                self.assertEqual(None, factory.parents)
1721
2167
            else:
1722
2168
                self.assertValidStorageKind(factory.storage_kind)
1723
 
                self.assertEqual(files.get_sha1s([factory.key])[factory.key],
1724
 
                    factory.sha1)
 
2169
                if factory.sha1 is not None:
 
2170
                    sha1 = files.get_sha1s([factory.key])[factory.key]
 
2171
                    self.assertEqual(sha1, factory.sha1)
1725
2172
                self.assertEqual(parents[factory.key], factory.parents)
1726
2173
                self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
1727
2174
                    str)
1761
2208
        else:
1762
2209
            return None
1763
2210
 
 
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
 
1764
2247
    def test_get_parent_map(self):
1765
2248
        files = self.get_versionedfiles()
1766
2249
        if self.key_length == 1:
1817
2300
            keys[4]: '9ef09dfa9d86780bdec9219a22560c6ece8e0ef1',
1818
2301
            },
1819
2302
            files.get_sha1s(keys))
1820
 
        
 
2303
 
1821
2304
    def test_insert_record_stream_empty(self):
1822
2305
        """Inserting an empty record stream should work."""
1823
2306
        files = self.get_versionedfiles()
1969
2452
        else:
1970
2453
            self.assertIdenticalVersionedFile(source, files)
1971
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
 
 
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
 
1972
2504
    def test_insert_record_stream_delta_missing_basis_no_corruption(self):
1973
 
        """Insertion where a needed basis is not included aborts safely."""
1974
 
        # We use a knit always here to be sure we are getting a binary delta.
1975
 
        mapper = self.get_mapper()
1976
 
        source_transport = self.get_transport('source')
1977
 
        source_transport.mkdir('.')
1978
 
        source = make_file_factory(False, mapper)(source_transport)
1979
 
        self.get_diamond_files(source)
1980
 
        entries = source.get_record_stream(['origin', 'merged'], 'unordered', False)
1981
 
        files = self.get_versionedfiles()
1982
 
        self.assertRaises(RevisionNotPresent, files.insert_record_stream,
1983
 
            entries)
 
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())
1984
2557
        files.check()
1985
 
        self.assertEqual({}, files.get_parent_map([]))
1986
2558
 
1987
2559
    def test_iter_lines_added_or_present_in_keys(self):
1988
2560
        # test that we get at least an equalset of the lines added by
1990
2562
        # the ordering here is to make a tree so that dumb searches have
1991
2563
        # more changes to muck up.
1992
2564
 
1993
 
        class InstrumentedProgress(progress.DummyProgress):
 
2565
        class InstrumentedProgress(progress.ProgressTask):
1994
2566
 
1995
2567
            def __init__(self):
1996
 
 
1997
 
                progress.DummyProgress.__init__(self)
 
2568
                progress.ProgressTask.__init__(self)
1998
2569
                self.updates = []
1999
2570
 
2000
2571
            def update(self, msg=None, current=None, total=None):
2031
2602
            return lines
2032
2603
        lines = iter_with_keys(
2033
2604
            [self.get_simple_key('child'), self.get_simple_key('otherchild')],
2034
 
            [('Walking content.', 0, 2),
2035
 
             ('Walking content.', 1, 2),
2036
 
             ('Walking content.', 2, 2)])
 
2605
            [('Walking content', 0, 2),
 
2606
             ('Walking content', 1, 2),
 
2607
             ('Walking content', 2, 2)])
2037
2608
        # we must see child and otherchild
2038
2609
        self.assertTrue(lines[('child\n', self.get_simple_key('child'))] > 0)
2039
2610
        self.assertTrue(
2040
2611
            lines[('otherchild\n', self.get_simple_key('otherchild'))] > 0)
2041
2612
        # we dont care if we got more than that.
2042
 
        
 
2613
 
2043
2614
        # test all lines
2044
2615
        lines = iter_with_keys(files.keys(),
2045
 
            [('Walking content.', 0, 5),
2046
 
             ('Walking content.', 1, 5),
2047
 
             ('Walking content.', 2, 5),
2048
 
             ('Walking content.', 3, 5),
2049
 
             ('Walking content.', 4, 5),
2050
 
             ('Walking content.', 5, 5)])
 
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)])
2051
2622
        # all lines must be seen at least once
2052
2623
        self.assertTrue(lines[('base\n', self.get_simple_key('base'))] > 0)
2053
2624
        self.assertTrue(
2086
2657
        files.add_lines(self.get_simple_key('noeolbase'), [], ['line'])
2087
2658
        # noeol preceeding its leftmost parent in the output:
2088
2659
        # this is done by making it a merge of two parents with no common
2089
 
        # anestry: noeolbase and noeol with the 
 
2660
        # anestry: noeolbase and noeol with the
2090
2661
        # later-inserted parent the leftmost.
2091
2662
        files.add_lines(self.get_simple_key('eolbeforefirstparent'),
2092
2663
            self.get_parents([self.get_simple_key('noeolbase'),
2178
2749
        TestCase.setUp(self)
2179
2750
        self._lines = {}
2180
2751
        self._parent_map = {}
2181
 
        self.texts = VirtualVersionedFiles(self._get_parent_map, 
 
2752
        self.texts = VirtualVersionedFiles(self._get_parent_map,
2182
2753
                                           self._lines.get)
2183
2754
 
2184
2755
    def test_add_lines(self):
2185
 
        self.assertRaises(NotImplementedError, 
 
2756
        self.assertRaises(NotImplementedError,
2186
2757
                self.texts.add_lines, "foo", [], [])
2187
2758
 
2188
2759
    def test_add_mpdiffs(self):
2189
 
        self.assertRaises(NotImplementedError, 
 
2760
        self.assertRaises(NotImplementedError,
2190
2761
                self.texts.add_mpdiffs, [])
2191
2762
 
2192
 
    def test_check(self):
2193
 
        self.assertTrue(self.texts.check())
 
2763
    def test_check_noerrors(self):
 
2764
        self.texts.check()
2194
2765
 
2195
2766
    def test_insert_record_stream(self):
2196
2767
        self.assertRaises(NotImplementedError, self.texts.insert_record_stream,
2206
2777
 
2207
2778
    def test_get_parent_map(self):
2208
2779
        self._parent_map = {"G": ("A", "B")}
2209
 
        self.assertEquals({("G",): (("A",),("B",))}, 
 
2780
        self.assertEquals({("G",): (("A",),("B",))},
2210
2781
                          self.texts.get_parent_map([("G",), ("L",)]))
2211
2782
 
2212
2783
    def test_get_record_stream(self):
2227
2798
        self._lines["B"] = ["HEY"]
2228
2799
        self._lines["C"] = ["Alberta"]
2229
2800
        it = self.texts.iter_lines_added_or_present_in_keys([("A",), ("B",)])
2230
 
        self.assertEquals(sorted([("FOO", "A"), ("BAR", "A"), ("HEY", "B")]), 
 
2801
        self.assertEquals(sorted([("FOO", "A"), ("BAR", "A"), ("HEY", "B")]),
2231
2802
            sorted(list(it)))
2232
2803
 
2233
2804