← 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: Aaron Bentley
  • Date: 2012-07-13 19:32:33 UTC
  • mto: This revision was merged to the branch mainline in revision 6540.
  • Revision ID: aaron@aaronbentley.com-20120713193233-l6y0l0twwhd3wmka
Switch to much simpler implementation of restore_uncommitted.

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 gzip import GzipFile
 
25
from itertools import chain, izip
24
26
from StringIO import StringIO
25
27
 
26
 
import bzrlib
27
28
from bzrlib import (
28
29
    errors,
 
30
    graph as _mod_graph,
 
31
    groupcompress,
 
32
    knit as _mod_knit,
29
33
    osutils,
30
34
    progress,
 
35
    transport,
 
36
    ui,
31
37
    )
32
38
from bzrlib.errors import (
33
 
                           RevisionNotPresent, 
 
39
                           RevisionNotPresent,
34
40
                           RevisionAlreadyPresent,
35
 
                           WeaveParentMismatch
36
41
                           )
37
42
from bzrlib.knit import (
38
 
    KnitVersionedFile,
39
 
    KnitAnnotateFactory,
40
 
    KnitPlainFactory,
41
 
    )
42
 
from bzrlib.tests import TestCaseWithMemoryTransport, TestSkipped
43
 
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
44
 
from bzrlib.trace import mutter
45
 
from bzrlib.transport import get_transport
 
43
    cleanup_pack_knit,
 
44
    make_file_factory,
 
45
    make_pack_factory,
 
46
    )
 
47
from bzrlib.tests import (
 
48
    TestCase,
 
49
    TestCaseWithMemoryTransport,
 
50
    TestNotApplicable,
 
51
    TestSkipped,
 
52
    )
 
53
from bzrlib.tests.http_utils import TestCaseWithWebserver
46
54
from bzrlib.transport.memory import MemoryTransport
47
 
from bzrlib.tsort import topo_sort
48
55
import bzrlib.versionedfile as versionedfile
 
56
from bzrlib.versionedfile import (
 
57
    ConstantMapper,
 
58
    HashEscapedPrefixMapper,
 
59
    PrefixMapper,
 
60
    VirtualVersionedFiles,
 
61
    make_versioned_files_factory,
 
62
    )
49
63
from bzrlib.weave import WeaveFile
50
 
from bzrlib.weavefile import read_weave, write_weave
 
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
 
 
70
 
 
71
def get_diamond_vf(f, trailing_eol=True, left_only=False):
 
72
    """Get a diamond graph to exercise deltas and merges.
 
73
 
 
74
    :param trailing_eol: If True end the last line with \n.
 
75
    """
 
76
    parents = {
 
77
        'origin': (),
 
78
        'base': (('origin',),),
 
79
        'left': (('base',),),
 
80
        'right': (('base',),),
 
81
        'merged': (('left',), ('right',)),
 
82
        }
 
83
    # insert a diamond graph to exercise deltas and merges.
 
84
    if trailing_eol:
 
85
        last_char = '\n'
 
86
    else:
 
87
        last_char = ''
 
88
    f.add_lines('origin', [], ['origin' + last_char])
 
89
    f.add_lines('base', ['origin'], ['base' + last_char])
 
90
    f.add_lines('left', ['base'], ['base\n', 'left' + last_char])
 
91
    if not left_only:
 
92
        f.add_lines('right', ['base'],
 
93
            ['base\n', 'right' + last_char])
 
94
        f.add_lines('merged', ['left', 'right'],
 
95
            ['base\n', 'left\n', 'right\n', 'merged' + last_char])
 
96
    return f, parents
 
97
 
 
98
 
 
99
def get_diamond_files(files, key_length, trailing_eol=True, left_only=False,
 
100
    nograph=False, nokeys=False):
 
101
    """Get a diamond graph to exercise deltas and merges.
 
102
 
 
103
    This creates a 5-node graph in files. If files supports 2-length keys two
 
104
    graphs are made to exercise the support for multiple ids.
 
105
 
 
106
    :param trailing_eol: If True end the last line with \n.
 
107
    :param key_length: The length of keys in files. Currently supports length 1
 
108
        and 2 keys.
 
109
    :param left_only: If True do not add the right and merged nodes.
 
110
    :param nograph: If True, do not provide parents to the add_lines calls;
 
111
        this is useful for tests that need inserted data but have graphless
 
112
        stores.
 
113
    :param nokeys: If True, pass None is as the key for all insertions.
 
114
        Currently implies nograph.
 
115
    :return: The results of the add_lines calls.
 
116
    """
 
117
    if nokeys:
 
118
        nograph = True
 
119
    if key_length == 1:
 
120
        prefixes = [()]
 
121
    else:
 
122
        prefixes = [('FileA',), ('FileB',)]
 
123
    # insert a diamond graph to exercise deltas and merges.
 
124
    if trailing_eol:
 
125
        last_char = '\n'
 
126
    else:
 
127
        last_char = ''
 
128
    result = []
 
129
    def get_parents(suffix_list):
 
130
        if nograph:
 
131
            return ()
 
132
        else:
 
133
            result = [prefix + suffix for suffix in suffix_list]
 
134
            return result
 
135
    def get_key(suffix):
 
136
        if nokeys:
 
137
            return (None, )
 
138
        else:
 
139
            return (suffix,)
 
140
    # we loop over each key because that spreads the inserts across prefixes,
 
141
    # which is how commit operates.
 
142
    for prefix in prefixes:
 
143
        result.append(files.add_lines(prefix + get_key('origin'), (),
 
144
            ['origin' + last_char]))
 
145
    for prefix in prefixes:
 
146
        result.append(files.add_lines(prefix + get_key('base'),
 
147
            get_parents([('origin',)]), ['base' + last_char]))
 
148
    for prefix in prefixes:
 
149
        result.append(files.add_lines(prefix + get_key('left'),
 
150
            get_parents([('base',)]),
 
151
            ['base\n', 'left' + last_char]))
 
152
    if not left_only:
 
153
        for prefix in prefixes:
 
154
            result.append(files.add_lines(prefix + get_key('right'),
 
155
                get_parents([('base',)]),
 
156
                ['base\n', 'right' + last_char]))
 
157
        for prefix in prefixes:
 
158
            result.append(files.add_lines(prefix + get_key('merged'),
 
159
                get_parents([('left',), ('right',)]),
 
160
                ['base\n', 'left\n', 'right\n', 'merged' + last_char]))
 
161
    return result
51
162
 
52
163
 
53
164
class VersionedFileTestMixIn(object):
58
169
    they are strictly controlled by their owning repositories.
59
170
    """
60
171
 
 
172
    def get_transaction(self):
 
173
        if not hasattr(self, '_transaction'):
 
174
            self._transaction = None
 
175
        return self._transaction
 
176
 
61
177
    def test_add(self):
62
178
        f = self.get_file()
63
179
        f.add_lines('r0', [], ['a\n', 'b\n'])
71
187
            self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
72
188
            self.assertEqual(2, len(f))
73
189
            self.assertEqual(2, f.num_versions())
74
 
    
 
190
 
75
191
            self.assertRaises(RevisionNotPresent,
76
192
                f.add_lines, 'r2', ['foo'], [])
77
193
            self.assertRaises(RevisionAlreadyPresent,
84
200
    def test_adds_with_parent_texts(self):
85
201
        f = self.get_file()
86
202
        parent_texts = {}
87
 
        parent_texts['r0'] = f.add_lines('r0', [], ['a\n', 'b\n'])
 
203
        _, _, parent_texts['r0'] = f.add_lines('r0', [], ['a\n', 'b\n'])
88
204
        try:
89
 
            parent_texts['r1'] = f.add_lines_with_ghosts('r1',
90
 
                                                         ['r0', 'ghost'], 
91
 
                                                         ['b\n', 'c\n'],
92
 
                                                         parent_texts=parent_texts)
 
205
            _, _, parent_texts['r1'] = f.add_lines_with_ghosts('r1',
 
206
                ['r0', 'ghost'], ['b\n', 'c\n'], parent_texts=parent_texts)
93
207
        except NotImplementedError:
94
208
            # if the format doesn't support ghosts, just add normally.
95
 
            parent_texts['r1'] = f.add_lines('r1',
96
 
                                             ['r0'], 
97
 
                                             ['b\n', 'c\n'],
98
 
                                             parent_texts=parent_texts)
 
209
            _, _, parent_texts['r1'] = f.add_lines('r1',
 
210
                ['r0'], ['b\n', 'c\n'], parent_texts=parent_texts)
99
211
        f.add_lines('r2', ['r1'], ['c\n', 'd\n'], parent_texts=parent_texts)
100
212
        self.assertNotEqual(None, parent_texts['r0'])
101
213
        self.assertNotEqual(None, parent_texts['r1'])
120
232
        verify_file(f)
121
233
 
122
234
    def test_add_unicode_content(self):
123
 
        # unicode content is not permitted in versioned files. 
 
235
        # unicode content is not permitted in versioned files.
124
236
        # versioned files version sequences of bytes only.
125
237
        vf = self.get_file()
126
238
        self.assertRaises(errors.BzrBadParameterUnicode,
141
253
        vf.add_lines('1', [], ['a\n'])
142
254
        vf.add_lines('2', ['1'], ['a\n', 'a\n', 'a\n'],
143
255
                     left_matching_blocks=[(0, 0, 1), (1, 3, 0)])
144
 
        self.assertEqual([(1, 1, 2, [('2', 'a\n'), ('2', 'a\n')])],
145
 
                         vf.get_delta('2')[3])
 
256
        self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('2'))
146
257
        vf.add_lines('3', ['1'], ['a\n', 'a\n', 'a\n'],
147
258
                     left_matching_blocks=[(0, 2, 1), (1, 3, 0)])
148
 
        self.assertEqual([(0, 0, 2, [('3', 'a\n'), ('3', 'a\n')])],
149
 
                         vf.get_delta('3')[3])
 
259
        self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('3'))
150
260
 
151
261
    def test_inline_newline_throws(self):
152
262
        # \r characters are not permitted in lines being added
153
263
        vf = self.get_file()
154
 
        self.assertRaises(errors.BzrBadParameterContainsNewline, 
 
264
        self.assertRaises(errors.BzrBadParameterContainsNewline,
155
265
            vf.add_lines, 'a', [], ['a\n\n'])
156
266
        self.assertRaises(
157
267
            (errors.BzrBadParameterContainsNewline, NotImplementedError),
168
278
        self.assertRaises(errors.ReservedId,
169
279
            vf.add_lines, 'a:', [], ['a\n', 'b\n', 'c\n'])
170
280
 
171
 
        self.assertRaises(errors.ReservedId,
172
 
            vf.add_delta, 'a:', [], None, 'sha1', False, ((0, 0, 0, []),))
 
281
    def test_add_lines_nostoresha(self):
 
282
        """When nostore_sha is supplied using old content raises."""
 
283
        vf = self.get_file()
 
284
        empty_text = ('a', [])
 
285
        sample_text_nl = ('b', ["foo\n", "bar\n"])
 
286
        sample_text_no_nl = ('c', ["foo\n", "bar"])
 
287
        shas = []
 
288
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
 
289
            sha, _, _ = vf.add_lines(version, [], lines)
 
290
            shas.append(sha)
 
291
        # we now have a copy of all the lines in the vf.
 
292
        for sha, (version, lines) in zip(
 
293
            shas, (empty_text, sample_text_nl, sample_text_no_nl)):
 
294
            self.assertRaises(errors.ExistingContent,
 
295
                vf.add_lines, version + "2", [], lines,
 
296
                nostore_sha=sha)
 
297
            # and no new version should have been added.
 
298
            self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
 
299
                version + "2")
 
300
 
 
301
    def test_add_lines_with_ghosts_nostoresha(self):
 
302
        """When nostore_sha is supplied using old content raises."""
 
303
        vf = self.get_file()
 
304
        empty_text = ('a', [])
 
305
        sample_text_nl = ('b', ["foo\n", "bar\n"])
 
306
        sample_text_no_nl = ('c', ["foo\n", "bar"])
 
307
        shas = []
 
308
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
 
309
            sha, _, _ = vf.add_lines(version, [], lines)
 
310
            shas.append(sha)
 
311
        # we now have a copy of all the lines in the vf.
 
312
        # is the test applicable to this vf implementation?
 
313
        try:
 
314
            vf.add_lines_with_ghosts('d', [], [])
 
315
        except NotImplementedError:
 
316
            raise TestSkipped("add_lines_with_ghosts is optional")
 
317
        for sha, (version, lines) in zip(
 
318
            shas, (empty_text, sample_text_nl, sample_text_no_nl)):
 
319
            self.assertRaises(errors.ExistingContent,
 
320
                vf.add_lines_with_ghosts, version + "2", [], lines,
 
321
                nostore_sha=sha)
 
322
            # and no new version should have been added.
 
323
            self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
 
324
                version + "2")
 
325
 
 
326
    def test_add_lines_return_value(self):
 
327
        # add_lines should return the sha1 and the text size.
 
328
        vf = self.get_file()
 
329
        empty_text = ('a', [])
 
330
        sample_text_nl = ('b', ["foo\n", "bar\n"])
 
331
        sample_text_no_nl = ('c', ["foo\n", "bar"])
 
332
        # check results for the three cases:
 
333
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
 
334
            # the first two elements are the same for all versioned files:
 
335
            # - the digest and the size of the text. For some versioned files
 
336
            #   additional data is returned in additional tuple elements.
 
337
            result = vf.add_lines(version, [], lines)
 
338
            self.assertEqual(3, len(result))
 
339
            self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
 
340
                result[0:2])
 
341
        # parents should not affect the result:
 
342
        lines = sample_text_nl[1]
 
343
        self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
 
344
            vf.add_lines('d', ['b', 'c'], lines)[0:2])
173
345
 
174
346
    def test_get_reserved(self):
175
347
        vf = self.get_file()
176
 
        self.assertRaises(errors.ReservedId, vf.get_delta, 'b:')
177
348
        self.assertRaises(errors.ReservedId, vf.get_texts, ['b:'])
178
349
        self.assertRaises(errors.ReservedId, vf.get_lines, 'b:')
179
350
        self.assertRaises(errors.ReservedId, vf.get_text, 'b:')
180
351
 
181
 
    def test_get_delta(self):
182
 
        f = self.get_file()
183
 
        sha1s = self._setup_for_deltas(f)
184
 
        expected_delta = (None, '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
185
 
                          [(0, 0, 1, [('base', 'line\n')])])
186
 
        self.assertEqual(expected_delta, f.get_delta('base'))
187
 
        next_parent = 'base'
188
 
        text_name = 'chain1-'
189
 
        for depth in range(26):
190
 
            new_version = text_name + '%s' % depth
191
 
            expected_delta = (next_parent, sha1s[depth], 
192
 
                              False,
193
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
194
 
            self.assertEqual(expected_delta, f.get_delta(new_version))
195
 
            next_parent = new_version
196
 
        next_parent = 'base'
197
 
        text_name = 'chain2-'
198
 
        for depth in range(26):
199
 
            new_version = text_name + '%s' % depth
200
 
            expected_delta = (next_parent, sha1s[depth], False,
201
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
202
 
            self.assertEqual(expected_delta, f.get_delta(new_version))
203
 
            next_parent = new_version
204
 
        # smoke test for eol support
205
 
        expected_delta = ('base', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, [])
206
 
        self.assertEqual(['line'], f.get_lines('noeol'))
207
 
        self.assertEqual(expected_delta, f.get_delta('noeol'))
208
 
 
209
 
    def test_get_deltas(self):
210
 
        f = self.get_file()
211
 
        sha1s = self._setup_for_deltas(f)
212
 
        deltas = f.get_deltas(f.versions())
213
 
        expected_delta = (None, '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
214
 
                          [(0, 0, 1, [('base', 'line\n')])])
215
 
        self.assertEqual(expected_delta, deltas['base'])
216
 
        next_parent = 'base'
217
 
        text_name = 'chain1-'
218
 
        for depth in range(26):
219
 
            new_version = text_name + '%s' % depth
220
 
            expected_delta = (next_parent, sha1s[depth], 
221
 
                              False,
222
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
223
 
            self.assertEqual(expected_delta, deltas[new_version])
224
 
            next_parent = new_version
225
 
        next_parent = 'base'
226
 
        text_name = 'chain2-'
227
 
        for depth in range(26):
228
 
            new_version = text_name + '%s' % depth
229
 
            expected_delta = (next_parent, sha1s[depth], False,
230
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
231
 
            self.assertEqual(expected_delta, deltas[new_version])
232
 
            next_parent = new_version
233
 
        # smoke tests for eol support
234
 
        expected_delta = ('base', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, [])
235
 
        self.assertEqual(['line'], f.get_lines('noeol'))
236
 
        self.assertEqual(expected_delta, deltas['noeol'])
237
 
        # smoke tests for eol support - two noeol in a row same content
238
 
        expected_deltas = (('noeol', '3ad7ee82dbd8f29ecba073f96e43e414b3f70a4d', True, 
239
 
                          [(0, 1, 2, [('noeolsecond', 'line\n'), ('noeolsecond', 'line\n')])]),
240
 
                          ('noeol', '3ad7ee82dbd8f29ecba073f96e43e414b3f70a4d', True, 
241
 
                           [(0, 0, 1, [('noeolsecond', 'line\n')]), (1, 1, 0, [])]))
242
 
        self.assertEqual(['line\n', 'line'], f.get_lines('noeolsecond'))
243
 
        self.assertTrue(deltas['noeolsecond'] in expected_deltas)
244
 
        # two no-eol in a row, different content
245
 
        expected_delta = ('noeolsecond', '8bb553a84e019ef1149db082d65f3133b195223b', True, 
246
 
                          [(1, 2, 1, [('noeolnotshared', 'phone\n')])])
247
 
        self.assertEqual(['line\n', 'phone'], f.get_lines('noeolnotshared'))
248
 
        self.assertEqual(expected_delta, deltas['noeolnotshared'])
249
 
        # eol folling a no-eol with content change
250
 
        expected_delta = ('noeol', 'a61f6fb6cfc4596e8d88c34a308d1e724caf8977', False, 
251
 
                          [(0, 1, 1, [('eol', 'phone\n')])])
252
 
        self.assertEqual(['phone\n'], f.get_lines('eol'))
253
 
        self.assertEqual(expected_delta, deltas['eol'])
254
 
        # eol folling a no-eol with content change
255
 
        expected_delta = ('noeol', '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
256
 
                          [(0, 1, 1, [('eolline', 'line\n')])])
257
 
        self.assertEqual(['line\n'], f.get_lines('eolline'))
258
 
        self.assertEqual(expected_delta, deltas['eolline'])
259
 
        # eol with no parents
260
 
        expected_delta = (None, '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, 
261
 
                          [(0, 0, 1, [('noeolbase', 'line\n')])])
262
 
        self.assertEqual(['line'], f.get_lines('noeolbase'))
263
 
        self.assertEqual(expected_delta, deltas['noeolbase'])
264
 
        # eol with two parents, in inverse insertion order
265
 
        expected_deltas = (('noeolbase', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True,
266
 
                            [(0, 1, 1, [('eolbeforefirstparent', 'line\n')])]),
267
 
                           ('noeolbase', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True,
268
 
                            [(0, 1, 1, [('eolbeforefirstparent', 'line\n')])]))
269
 
        self.assertEqual(['line'], f.get_lines('eolbeforefirstparent'))
270
 
        #self.assertTrue(deltas['eolbeforefirstparent'] in expected_deltas)
 
352
    def test_add_unchanged_last_line_noeol_snapshot(self):
 
353
        """Add a text with an unchanged last line with no eol should work."""
 
354
        # Test adding this in a number of chain lengths; because the interface
 
355
        # for VersionedFile does not allow forcing a specific chain length, we
 
356
        # just use a small base to get the first snapshot, then a much longer
 
357
        # first line for the next add (which will make the third add snapshot)
 
358
        # and so on. 20 has been chosen as an aribtrary figure - knits use 200
 
359
        # as a capped delta length, but ideally we would have some way of
 
360
        # tuning the test to the store (e.g. keep going until a snapshot
 
361
        # happens).
 
362
        for length in range(20):
 
363
            version_lines = {}
 
364
            vf = self.get_file('case-%d' % length)
 
365
            prefix = 'step-%d'
 
366
            parents = []
 
367
            for step in range(length):
 
368
                version = prefix % step
 
369
                lines = (['prelude \n'] * step) + ['line']
 
370
                vf.add_lines(version, parents, lines)
 
371
                version_lines[version] = lines
 
372
                parents = [version]
 
373
            vf.add_lines('no-eol', parents, ['line'])
 
374
            vf.get_texts(version_lines.keys())
 
375
            self.assertEqualDiff('line', vf.get_text('no-eol'))
 
376
 
 
377
    def test_get_texts_eol_variation(self):
 
378
        # similar to the failure in <http://bugs.launchpad.net/234748>
 
379
        vf = self.get_file()
 
380
        sample_text_nl = ["line\n"]
 
381
        sample_text_no_nl = ["line"]
 
382
        versions = []
 
383
        version_lines = {}
 
384
        parents = []
 
385
        for i in range(4):
 
386
            version = 'v%d' % i
 
387
            if i % 2:
 
388
                lines = sample_text_nl
 
389
            else:
 
390
                lines = sample_text_no_nl
 
391
            # left_matching blocks is an internal api; it operates on the
 
392
            # *internal* representation for a knit, which is with *all* lines
 
393
            # being normalised to end with \n - even the final line in a no_nl
 
394
            # file. Using it here ensures that a broken internal implementation
 
395
            # (which is what this test tests) will generate a correct line
 
396
            # delta (which is to say, an empty delta).
 
397
            vf.add_lines(version, parents, lines,
 
398
                left_matching_blocks=[(0, 0, 1)])
 
399
            parents = [version]
 
400
            versions.append(version)
 
401
            version_lines[version] = lines
 
402
        vf.check()
 
403
        vf.get_texts(versions)
 
404
        vf.get_texts(reversed(versions))
 
405
 
 
406
    def test_add_lines_with_matching_blocks_noeol_last_line(self):
 
407
        """Add a text with an unchanged last line with no eol should work."""
 
408
        from bzrlib import multiparent
 
409
        # Hand verified sha1 of the text we're adding.
 
410
        sha1 = '6a1d115ec7b60afb664dc14890b5af5ce3c827a4'
 
411
        # Create a mpdiff which adds a new line before the trailing line, and
 
412
        # reuse the last line unaltered (which can cause annotation reuse).
 
413
        # Test adding this in two situations:
 
414
        # On top of a new insertion
 
415
        vf = self.get_file('fulltext')
 
416
        vf.add_lines('noeol', [], ['line'])
 
417
        vf.add_lines('noeol2', ['noeol'], ['newline\n', 'line'],
 
418
            left_matching_blocks=[(0, 1, 1)])
 
419
        self.assertEqualDiff('newline\nline', vf.get_text('noeol2'))
 
420
        # On top of a delta
 
421
        vf = self.get_file('delta')
 
422
        vf.add_lines('base', [], ['line'])
 
423
        vf.add_lines('noeol', ['base'], ['prelude\n', 'line'])
 
424
        vf.add_lines('noeol2', ['noeol'], ['newline\n', 'line'],
 
425
            left_matching_blocks=[(1, 1, 1)])
 
426
        self.assertEqualDiff('newline\nline', vf.get_text('noeol2'))
271
427
 
272
428
    def test_make_mpdiffs(self):
273
429
        from bzrlib import multiparent
276
432
        new_vf = self.get_file('bar')
277
433
        for version in multiparent.topo_iter(vf):
278
434
            mpdiff = vf.make_mpdiffs([version])[0]
279
 
            new_vf.add_mpdiffs([(version, vf.get_parents(version),
280
 
                                 vf.get_sha1(version), mpdiff)])
 
435
            new_vf.add_mpdiffs([(version, vf.get_parent_map([version])[version],
 
436
                                 vf.get_sha1s([version])[version], mpdiff)])
281
437
            self.assertEqualDiff(vf.get_text(version),
282
438
                                 new_vf.get_text(version))
283
439
 
 
440
    def test_make_mpdiffs_with_ghosts(self):
 
441
        vf = self.get_file('foo')
 
442
        try:
 
443
            vf.add_lines_with_ghosts('text', ['ghost'], ['line\n'])
 
444
        except NotImplementedError:
 
445
            # old Weave formats do not allow ghosts
 
446
            return
 
447
        self.assertRaises(errors.RevisionNotPresent, vf.make_mpdiffs, ['ghost'])
 
448
 
284
449
    def _setup_for_deltas(self, f):
285
 
        self.assertRaises(errors.RevisionNotPresent, f.get_delta, 'base')
 
450
        self.assertFalse(f.has_version('base'))
286
451
        # add texts that should trip the knit maximum delta chain threshold
287
452
        # as well as doing parallel chains of data in knits.
288
453
        # this is done by two chains of 25 insertions
301
466
        f.add_lines('noeolbase', [], ['line'])
302
467
        # noeol preceeding its leftmost parent in the output:
303
468
        # this is done by making it a merge of two parents with no common
304
 
        # anestry: noeolbase and noeol with the 
 
469
        # anestry: noeolbase and noeol with the
305
470
        # later-inserted parent the leftmost.
306
471
        f.add_lines('eolbeforefirstparent', ['noeolbase', 'noeol'], ['line'])
307
472
        # two identical eol texts
351
516
            next_parent = new_version
352
517
        return sha1s
353
518
 
354
 
    def test_add_delta(self):
355
 
        # tests for the add-delta facility.
356
 
        # at this point, optimising for speed, we assume no checks when deltas are inserted.
357
 
        # this may need to be revisited.
358
 
        source = self.get_file('source')
359
 
        source.add_lines('base', [], ['line\n'])
360
 
        next_parent = 'base'
361
 
        text_name = 'chain1-'
362
 
        text = ['line\n']
363
 
        for depth in range(26):
364
 
            new_version = text_name + '%s' % depth
365
 
            text = text + ['line\n']
366
 
            source.add_lines(new_version, [next_parent], text)
367
 
            next_parent = new_version
368
 
        next_parent = 'base'
369
 
        text_name = 'chain2-'
370
 
        text = ['line\n']
371
 
        for depth in range(26):
372
 
            new_version = text_name + '%s' % depth
373
 
            text = text + ['line\n']
374
 
            source.add_lines(new_version, [next_parent], text)
375
 
            next_parent = new_version
376
 
        source.add_lines('noeol', ['base'], ['line'])
377
 
        
378
 
        target = self.get_file('target')
379
 
        for version in source.versions():
380
 
            parent, sha1, noeol, delta = source.get_delta(version)
381
 
            target.add_delta(version,
382
 
                             source.get_parents(version),
383
 
                             parent,
384
 
                             sha1,
385
 
                             noeol,
386
 
                             delta)
387
 
        self.assertRaises(RevisionAlreadyPresent,
388
 
                          target.add_delta, 'base', [], None, '', False, [])
389
 
        for version in source.versions():
390
 
            self.assertEqual(source.get_lines(version),
391
 
                             target.get_lines(version))
392
 
 
393
519
    def test_ancestry(self):
394
520
        f = self.get_file()
395
521
        self.assertEqual([], f.get_ancestry([]))
422
548
            set(f.get_ancestry('rM', topo_sorted=False)))
423
549
 
424
550
    def test_mutate_after_finish(self):
 
551
        self._transaction = 'before'
425
552
        f = self.get_file()
426
 
        f.transaction_finished()
427
 
        self.assertRaises(errors.OutSideTransaction, f.add_delta, '', [], '', '', False, [])
 
553
        self._transaction = 'after'
428
554
        self.assertRaises(errors.OutSideTransaction, f.add_lines, '', [], [])
429
555
        self.assertRaises(errors.OutSideTransaction, f.add_lines_with_ghosts, '', [], [])
430
 
        self.assertRaises(errors.OutSideTransaction, f.fix_parents, '', [])
431
 
        self.assertRaises(errors.OutSideTransaction, f.join, '')
432
 
        self.assertRaises(errors.OutSideTransaction, f.clone_text, 'base', 'bar', ['foo'])
433
 
        
434
 
    def test_clear_cache(self):
435
 
        f = self.get_file()
436
 
        # on a new file it should not error
437
 
        f.clear_cache()
438
 
        # and after adding content, doing a clear_cache and a get should work.
439
 
        f.add_lines('0', [], ['a'])
440
 
        f.clear_cache()
441
 
        self.assertEqual(['a'], f.get_lines('0'))
442
 
 
443
 
    def test_clone_text(self):
444
 
        f = self.get_file()
445
 
        f.add_lines('r0', [], ['a\n', 'b\n'])
446
 
        f.clone_text('r1', 'r0', ['r0'])
447
 
        def verify_file(f):
448
 
            self.assertEquals(f.get_lines('r1'), f.get_lines('r0'))
449
 
            self.assertEquals(f.get_lines('r1'), ['a\n', 'b\n'])
450
 
            self.assertEquals(f.get_parents('r1'), ['r0'])
451
 
    
452
 
            self.assertRaises(RevisionNotPresent,
453
 
                f.clone_text, 'r2', 'rX', [])
454
 
            self.assertRaises(RevisionAlreadyPresent,
455
 
                f.clone_text, 'r1', 'r0', [])
456
 
        verify_file(f)
457
 
        verify_file(self.reopen_file())
458
 
 
459
 
    def test_create_empty(self):
460
 
        f = self.get_file()
461
 
        f.add_lines('0', [], ['a\n'])
462
 
        new_f = f.create_empty('t', MemoryTransport())
463
 
        # smoke test, specific types should check it is honoured correctly for
464
 
        # non type attributes
465
 
        self.assertEqual([], new_f.versions())
466
 
        self.assertTrue(isinstance(new_f, f.__class__))
467
556
 
468
557
    def test_copy_to(self):
469
558
        f = self.get_file()
470
559
        f.add_lines('0', [], ['a\n'])
471
560
        t = MemoryTransport()
472
561
        f.copy_to('foo', t)
473
 
        for suffix in f.__class__.get_suffixes():
 
562
        for suffix in self.get_factory().get_suffixes():
474
563
            self.assertTrue(t.has('foo' + suffix))
475
564
 
476
565
    def test_get_suffixes(self):
477
566
        f = self.get_file()
478
 
        # should be the same
479
 
        self.assertEqual(f.__class__.get_suffixes(), f.__class__.get_suffixes())
480
567
        # and should be a list
481
 
        self.assertTrue(isinstance(f.__class__.get_suffixes(), list))
482
 
 
483
 
    def build_graph(self, file, graph):
484
 
        for node in topo_sort(graph.items()):
485
 
            file.add_lines(node, graph[node], [])
486
 
 
487
 
    def test_get_graph(self):
488
 
        f = self.get_file()
489
 
        graph = {
490
 
            'v1': (),
491
 
            'v2': ('v1', ),
492
 
            'v3': ('v2', )}
493
 
        self.build_graph(f, graph)
494
 
        self.assertEqual(graph, f.get_graph())
495
 
    
496
 
    def test_get_graph_partial(self):
497
 
        f = self.get_file()
498
 
        complex_graph = {}
499
 
        simple_a = {
500
 
            'c': (),
501
 
            'b': ('c', ),
502
 
            'a': ('b', ),
503
 
            }
504
 
        complex_graph.update(simple_a)
505
 
        simple_b = {
506
 
            'c': (),
507
 
            'b': ('c', ),
508
 
            }
509
 
        complex_graph.update(simple_b)
510
 
        simple_gam = {
511
 
            'c': (),
512
 
            'oo': (),
513
 
            'bar': ('oo', 'c'),
514
 
            'gam': ('bar', ),
515
 
            }
516
 
        complex_graph.update(simple_gam)
517
 
        simple_b_gam = {}
518
 
        simple_b_gam.update(simple_gam)
519
 
        simple_b_gam.update(simple_b)
520
 
        self.build_graph(f, complex_graph)
521
 
        self.assertEqual(simple_a, f.get_graph(['a']))
522
 
        self.assertEqual(simple_b, f.get_graph(['b']))
523
 
        self.assertEqual(simple_gam, f.get_graph(['gam']))
524
 
        self.assertEqual(simple_b_gam, f.get_graph(['b', 'gam']))
525
 
 
526
 
    def test_get_parents(self):
 
568
        self.assertTrue(isinstance(self.get_factory().get_suffixes(), list))
 
569
 
 
570
    def test_get_parent_map(self):
527
571
        f = self.get_file()
528
572
        f.add_lines('r0', [], ['a\n', 'b\n'])
529
 
        f.add_lines('r1', [], ['a\n', 'b\n'])
 
573
        self.assertEqual(
 
574
            {'r0':()}, f.get_parent_map(['r0']))
 
575
        f.add_lines('r1', ['r0'], ['a\n', 'b\n'])
 
576
        self.assertEqual(
 
577
            {'r1':('r0',)}, f.get_parent_map(['r1']))
 
578
        self.assertEqual(
 
579
            {'r0':(),
 
580
             'r1':('r0',)},
 
581
            f.get_parent_map(['r0', 'r1']))
530
582
        f.add_lines('r2', [], ['a\n', 'b\n'])
531
583
        f.add_lines('r3', [], ['a\n', 'b\n'])
532
584
        f.add_lines('m', ['r0', 'r1', 'r2', 'r3'], ['a\n', 'b\n'])
533
 
        self.assertEquals(f.get_parents('m'), ['r0', 'r1', 'r2', 'r3'])
534
 
 
535
 
        self.assertRaises(RevisionNotPresent,
536
 
            f.get_parents, 'y')
 
585
        self.assertEqual(
 
586
            {'m':('r0', 'r1', 'r2', 'r3')}, f.get_parent_map(['m']))
 
587
        self.assertEqual({}, f.get_parent_map('y'))
 
588
        self.assertEqual(
 
589
            {'r0':(),
 
590
             'r1':('r0',)},
 
591
            f.get_parent_map(['r0', 'y', 'r1']))
537
592
 
538
593
    def test_annotate(self):
539
594
        f = self.get_file()
575
630
        """Open the versioned file from disk again."""
576
631
        raise NotImplementedError(self.reopen_file)
577
632
 
578
 
    def test_iter_parents(self):
579
 
        """iter_parents returns the parents for many nodes."""
580
 
        f = self.get_file()
581
 
        # sample data:
582
 
        # no parents
583
 
        f.add_lines('r0', [], ['a\n', 'b\n'])
584
 
        # 1 parents
585
 
        f.add_lines('r1', ['r0'], ['a\n', 'b\n'])
586
 
        # 2 parents
587
 
        f.add_lines('r2', ['r1', 'r0'], ['a\n', 'b\n'])
588
 
        # XXX TODO a ghost
589
 
        # cases: each sample data individually:
590
 
        self.assertEqual(set([('r0', ())]),
591
 
            set(f.iter_parents(['r0'])))
592
 
        self.assertEqual(set([('r1', ('r0', ))]),
593
 
            set(f.iter_parents(['r1'])))
594
 
        self.assertEqual(set([('r2', ('r1', 'r0'))]),
595
 
            set(f.iter_parents(['r2'])))
596
 
        # no nodes returned for a missing node
597
 
        self.assertEqual(set(),
598
 
            set(f.iter_parents(['missing'])))
599
 
        # 1 node returned with missing nodes skipped
600
 
        self.assertEqual(set([('r1', ('r0', ))]),
601
 
            set(f.iter_parents(['ghost1', 'r1', 'ghost'])))
602
 
        # 2 nodes returned
603
 
        self.assertEqual(set([('r0', ()), ('r1', ('r0', ))]),
604
 
            set(f.iter_parents(['r0', 'r1'])))
605
 
        # 2 nodes returned, missing skipped
606
 
        self.assertEqual(set([('r0', ()), ('r1', ('r0', ))]),
607
 
            set(f.iter_parents(['a', 'r0', 'b', 'r1', 'c'])))
608
 
 
609
633
    def test_iter_lines_added_or_present_in_versions(self):
610
634
        # test that we get at least an equalset of the lines added by
611
 
        # versions in the weave 
 
635
        # versions in the weave
612
636
        # the ordering here is to make a tree so that dumb searches have
613
637
        # more changes to muck up.
614
638
 
615
 
        class InstrumentedProgress(progress.DummyProgress):
 
639
        class InstrumentedProgress(progress.ProgressTask):
616
640
 
617
641
            def __init__(self):
618
 
 
619
 
                progress.DummyProgress.__init__(self)
 
642
                progress.ProgressTask.__init__(self)
620
643
                self.updates = []
621
644
 
622
645
            def update(self, msg=None, current=None, total=None):
637
660
                     ['base\n', 'lancestor\n', 'otherchild\n'])
638
661
        def iter_with_versions(versions, expected):
639
662
            # now we need to see what lines are returned, and how often.
640
 
            lines = {'base\n':0,
641
 
                     'lancestor\n':0,
642
 
                     'rancestor\n':0,
643
 
                     'child\n':0,
644
 
                     'otherchild\n':0,
645
 
                     }
 
663
            lines = {}
646
664
            progress = InstrumentedProgress()
647
665
            # iterate over the lines
648
 
            for line in vf.iter_lines_added_or_present_in_versions(versions, 
 
666
            for line in vf.iter_lines_added_or_present_in_versions(versions,
649
667
                pb=progress):
 
668
                lines.setdefault(line, 0)
650
669
                lines[line] += 1
651
 
            if []!= progress.updates: 
 
670
            if []!= progress.updates:
652
671
                self.assertEqual(expected, progress.updates)
653
672
            return lines
654
673
        lines = iter_with_versions(['child', 'otherchild'],
655
 
                                   [('Walking content.', 0, 2),
656
 
                                    ('Walking content.', 1, 2),
657
 
                                    ('Walking content.', 2, 2)])
 
674
                                   [('Walking content', 0, 2),
 
675
                                    ('Walking content', 1, 2),
 
676
                                    ('Walking content', 2, 2)])
658
677
        # we must see child and otherchild
659
 
        self.assertTrue(lines['child\n'] > 0)
660
 
        self.assertTrue(lines['otherchild\n'] > 0)
 
678
        self.assertTrue(lines[('child\n', 'child')] > 0)
 
679
        self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
661
680
        # we dont care if we got more than that.
662
 
        
 
681
 
663
682
        # test all lines
664
 
        lines = iter_with_versions(None, [('Walking content.', 0, 5),
665
 
                                          ('Walking content.', 1, 5),
666
 
                                          ('Walking content.', 2, 5),
667
 
                                          ('Walking content.', 3, 5),
668
 
                                          ('Walking content.', 4, 5),
669
 
                                          ('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)])
670
689
        # all lines must be seen at least once
671
 
        self.assertTrue(lines['base\n'] > 0)
672
 
        self.assertTrue(lines['lancestor\n'] > 0)
673
 
        self.assertTrue(lines['rancestor\n'] > 0)
674
 
        self.assertTrue(lines['child\n'] > 0)
675
 
        self.assertTrue(lines['otherchild\n'] > 0)
676
 
 
677
 
    def test_fix_parents(self):
678
 
        # some versioned files allow incorrect parents to be corrected after
679
 
        # insertion - this may not fix ancestry..
680
 
        # if they do not supported, they just do not implement it.
681
 
        # we test this as an interface test to ensure that those that *do*
682
 
        # implementent it get it right.
683
 
        vf = self.get_file()
684
 
        vf.add_lines('notbase', [], [])
685
 
        vf.add_lines('base', [], [])
686
 
        try:
687
 
            vf.fix_parents('notbase', ['base'])
688
 
        except NotImplementedError:
689
 
            return
690
 
        self.assertEqual(['base'], vf.get_parents('notbase'))
691
 
        # open again, check it stuck.
692
 
        vf = self.get_file()
693
 
        self.assertEqual(['base'], vf.get_parents('notbase'))
694
 
 
695
 
    def test_fix_parents_with_ghosts(self):
696
 
        # when fixing parents, ghosts that are listed should not be ghosts
697
 
        # anymore.
698
 
        vf = self.get_file()
699
 
 
700
 
        try:
701
 
            vf.add_lines_with_ghosts('notbase', ['base', 'stillghost'], [])
702
 
        except NotImplementedError:
703
 
            return
704
 
        vf.add_lines('base', [], [])
705
 
        vf.fix_parents('notbase', ['base', 'stillghost'])
706
 
        self.assertEqual(['base'], vf.get_parents('notbase'))
707
 
        # open again, check it stuck.
708
 
        vf = self.get_file()
709
 
        self.assertEqual(['base'], vf.get_parents('notbase'))
710
 
        # and check the ghosts
711
 
        self.assertEqual(['base', 'stillghost'],
712
 
                         vf.get_parents_with_ghosts('notbase'))
 
690
        self.assertTrue(lines[('base\n', 'base')] > 0)
 
691
        self.assertTrue(lines[('lancestor\n', 'lancestor')] > 0)
 
692
        self.assertTrue(lines[('rancestor\n', 'rancestor')] > 0)
 
693
        self.assertTrue(lines[('child\n', 'child')] > 0)
 
694
        self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
713
695
 
714
696
    def test_add_lines_with_ghosts(self):
715
697
        # some versioned file formats allow lines to be added with parent
725
707
            vf.add_lines_with_ghosts('notbxbfse', [parent_id_utf8], [])
726
708
        except NotImplementedError:
727
709
            # check the other ghost apis are also not implemented
728
 
            self.assertRaises(NotImplementedError, vf.has_ghost, 'foo')
729
710
            self.assertRaises(NotImplementedError, vf.get_ancestry_with_ghosts, ['foo'])
730
711
            self.assertRaises(NotImplementedError, vf.get_parents_with_ghosts, 'foo')
731
 
            self.assertRaises(NotImplementedError, vf.get_graph_with_ghosts)
732
712
            return
733
713
        vf = self.reopen_file()
734
714
        # test key graph related apis: getncestry, _graph, get_parents
735
715
        # has_version
736
716
        # - these are ghost unaware and must not be reflect ghosts
737
717
        self.assertEqual(['notbxbfse'], vf.get_ancestry('notbxbfse'))
738
 
        self.assertEqual([], vf.get_parents('notbxbfse'))
739
 
        self.assertEqual({'notbxbfse':()}, vf.get_graph())
740
 
        self.assertFalse(self.callDeprecated([osutils._revision_id_warning],
741
 
                         vf.has_version, parent_id_unicode))
742
718
        self.assertFalse(vf.has_version(parent_id_utf8))
743
719
        # we have _with_ghost apis to give us ghost information.
744
720
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry_with_ghosts(['notbxbfse']))
745
721
        self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
746
 
        self.assertEqual({'notbxbfse':[parent_id_utf8]}, vf.get_graph_with_ghosts())
747
 
        self.assertTrue(self.callDeprecated([osutils._revision_id_warning],
748
 
                        vf.has_ghost, parent_id_unicode))
749
 
        self.assertTrue(vf.has_ghost(parent_id_utf8))
750
722
        # if we add something that is a ghost of another, it should correct the
751
723
        # results of the prior apis
752
 
        self.callDeprecated([osutils._revision_id_warning],
753
 
                            vf.add_lines, parent_id_unicode, [], [])
 
724
        vf.add_lines(parent_id_utf8, [], [])
754
725
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry(['notbxbfse']))
755
 
        self.assertEqual([parent_id_utf8], vf.get_parents('notbxbfse'))
756
 
        self.assertEqual({parent_id_utf8:(),
757
 
                          'notbxbfse':(parent_id_utf8, ),
758
 
                          },
759
 
                         vf.get_graph())
760
 
        self.assertTrue(self.callDeprecated([osutils._revision_id_warning],
761
 
                        vf.has_version, parent_id_unicode))
 
726
        self.assertEqual({'notbxbfse':(parent_id_utf8,)},
 
727
            vf.get_parent_map(['notbxbfse']))
762
728
        self.assertTrue(vf.has_version(parent_id_utf8))
763
729
        # we have _with_ghost apis to give us ghost information.
764
 
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry_with_ghosts(['notbxbfse']))
 
730
        self.assertEqual([parent_id_utf8, 'notbxbfse'],
 
731
            vf.get_ancestry_with_ghosts(['notbxbfse']))
765
732
        self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
766
 
        self.assertEqual({parent_id_utf8:[],
767
 
                          'notbxbfse':[parent_id_utf8],
768
 
                          },
769
 
                         vf.get_graph_with_ghosts())
770
 
        self.assertFalse(self.callDeprecated([osutils._revision_id_warning],
771
 
                         vf.has_ghost, parent_id_unicode))
772
 
        self.assertFalse(vf.has_ghost(parent_id_utf8))
773
733
 
774
734
    def test_add_lines_with_ghosts_after_normal_revs(self):
775
735
        # some versioned file formats allow lines to be added with parent
779
739
        vf = self.get_file()
780
740
        # probe for ghost support
781
741
        try:
782
 
            vf.has_ghost('hoo')
 
742
            vf.add_lines_with_ghosts('base', [], ['line\n', 'line_b\n'])
783
743
        except NotImplementedError:
784
744
            return
785
 
        vf.add_lines_with_ghosts('base', [], ['line\n', 'line_b\n'])
786
745
        vf.add_lines_with_ghosts('references_ghost',
787
746
                                 ['base', 'a_ghost'],
788
747
                                 ['line\n', 'line_b\n', 'line_c\n'])
792
751
        self.assertEquals(('references_ghost', 'line_c\n'), origins[2])
793
752
 
794
753
    def test_readonly_mode(self):
795
 
        transport = get_transport(self.get_url('.'))
 
754
        t = self.get_transport()
796
755
        factory = self.get_factory()
797
 
        vf = factory('id', transport, 0777, create=True, access_mode='w')
798
 
        vf = factory('id', transport, access_mode='r')
799
 
        self.assertRaises(errors.ReadOnlyError, vf.add_delta, '', [], '', '', False, [])
 
756
        vf = factory('id', t, 0777, create=True, access_mode='w')
 
757
        vf = factory('id', t, access_mode='r')
800
758
        self.assertRaises(errors.ReadOnlyError, vf.add_lines, 'base', [], [])
801
759
        self.assertRaises(errors.ReadOnlyError,
802
760
                          vf.add_lines_with_ghosts,
803
761
                          'base',
804
762
                          [],
805
763
                          [])
806
 
        self.assertRaises(errors.ReadOnlyError, vf.fix_parents, 'base', [])
807
 
        self.assertRaises(errors.ReadOnlyError, vf.join, 'base')
808
 
        self.assertRaises(errors.ReadOnlyError, vf.clone_text, 'base', 'bar', ['foo'])
809
 
    
810
 
    def test_get_sha1(self):
 
764
 
 
765
    def test_get_sha1s(self):
811
766
        # check the sha1 data is available
812
767
        vf = self.get_file()
813
768
        # a simple file
816
771
        vf.add_lines('b', ['a'], ['a\n'])
817
772
        # a file differing only in last newline.
818
773
        vf.add_lines('c', [], ['a'])
819
 
        self.assertEqual(
820
 
            '3f786850e387550fdab836ed7e6dc881de23001b', vf.get_sha1('a'))
821
 
        self.assertEqual(
822
 
            '3f786850e387550fdab836ed7e6dc881de23001b', vf.get_sha1('b'))
823
 
        self.assertEqual(
824
 
            '86f7e437faa5a7fce15d1ddcb9eaeaea377667b8', vf.get_sha1('c'))
 
774
        self.assertEqual({
 
775
            'a': '3f786850e387550fdab836ed7e6dc881de23001b',
 
776
            'c': '86f7e437faa5a7fce15d1ddcb9eaeaea377667b8',
 
777
            'b': '3f786850e387550fdab836ed7e6dc881de23001b',
 
778
            },
 
779
            vf.get_sha1s(['a', 'c', 'b']))
825
780
 
826
 
        self.assertEqual(['3f786850e387550fdab836ed7e6dc881de23001b',
827
 
                          '86f7e437faa5a7fce15d1ddcb9eaeaea377667b8',
828
 
                          '3f786850e387550fdab836ed7e6dc881de23001b'],
829
 
                          vf.get_sha1s(['a', 'c', 'b']))
830
 
        
831
781
 
832
782
class TestWeave(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
833
783
 
834
784
    def get_file(self, name='foo'):
835
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
 
785
        return WeaveFile(name, self.get_transport(),
 
786
                         create=True,
 
787
                         get_scope=self.get_transaction)
836
788
 
837
789
    def get_file_corrupted_text(self):
838
 
        w = WeaveFile('foo', get_transport(self.get_url('.')), create=True)
 
790
        w = WeaveFile('foo', self.get_transport(),
 
791
                      create=True,
 
792
                      get_scope=self.get_transaction)
839
793
        w.add_lines('v1', [], ['hello\n'])
840
794
        w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
841
 
        
 
795
 
842
796
        # We are going to invasively corrupt the text
843
797
        # Make sure the internals of weave are the same
844
798
        self.assertEqual([('{', 0)
848
802
                        , 'there\n'
849
803
                        , ('}', None)
850
804
                        ], w._weave)
851
 
        
 
805
 
852
806
        self.assertEqual(['f572d396fae9206628714fb2ce00f72e94f2258f'
853
807
                        , '90f265c6e75f1c8f9ab76dcf85528352c5f215ef'
854
808
                        ], w._sha1s)
855
809
        w.check()
856
 
        
 
810
 
857
811
        # Corrupted
858
812
        w._weave[4] = 'There\n'
859
813
        return w
863
817
        # Corrected
864
818
        w._weave[4] = 'there\n'
865
819
        self.assertEqual('hello\nthere\n', w.get_text('v2'))
866
 
        
 
820
 
867
821
        #Invalid checksum, first digit changed
868
822
        w._sha1s[1] =  'f0f265c6e75f1c8f9ab76dcf85528352c5f215ef'
869
823
        return w
870
824
 
871
825
    def reopen_file(self, name='foo', create=False):
872
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=create)
 
826
        return WeaveFile(name, self.get_transport(),
 
827
                         create=create,
 
828
                         get_scope=self.get_transaction)
873
829
 
874
830
    def test_no_implicit_create(self):
875
831
        self.assertRaises(errors.NoSuchFile,
876
832
                          WeaveFile,
877
833
                          'foo',
878
 
                          get_transport(self.get_url('.')))
 
834
                          self.get_transport(),
 
835
                          get_scope=self.get_transaction)
879
836
 
880
837
    def get_factory(self):
881
838
        return WeaveFile
882
839
 
883
840
 
884
 
class TestKnit(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
885
 
 
886
 
    def get_file(self, name='foo'):
887
 
        return self.get_factory()(name, get_transport(self.get_url('.')),
888
 
                                  delta=True, create=True)
889
 
 
890
 
    def get_factory(self):
891
 
        return KnitVersionedFile
892
 
 
893
 
    def get_file_corrupted_text(self):
894
 
        knit = self.get_file()
895
 
        knit.add_lines('v1', [], ['hello\n'])
896
 
        knit.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
897
 
        return knit
898
 
 
899
 
    def reopen_file(self, name='foo', create=False):
900
 
        return self.get_factory()(name, get_transport(self.get_url('.')),
901
 
            delta=True,
902
 
            create=create)
903
 
 
904
 
    def test_detection(self):
905
 
        knit = self.get_file()
906
 
        knit.check()
907
 
 
908
 
    def test_no_implicit_create(self):
909
 
        self.assertRaises(errors.NoSuchFile,
910
 
                          KnitVersionedFile,
911
 
                          'foo',
912
 
                          get_transport(self.get_url('.')))
913
 
 
914
 
 
915
 
class TestPlaintextKnit(TestKnit):
916
 
    """Test a knit with no cached annotations"""
917
 
 
918
 
    def _factory(self, name, transport, file_mode=None, access_mode=None,
919
 
                 delta=True, create=False):
920
 
        return KnitVersionedFile(name, transport, file_mode, access_mode,
921
 
                                 KnitPlainFactory(), delta=delta,
922
 
                                 create=create)
923
 
 
924
 
    def get_factory(self):
925
 
        return self._factory
926
 
 
927
 
 
928
 
class InterString(versionedfile.InterVersionedFile):
929
 
    """An inter-versionedfile optimised code path for strings.
930
 
 
931
 
    This is for use during testing where we use strings as versionedfiles
932
 
    so that none of the default regsitered interversionedfile classes will
933
 
    match - which lets us test the match logic.
934
 
    """
935
 
 
936
 
    @staticmethod
937
 
    def is_compatible(source, target):
938
 
        """InterString is compatible with strings-as-versionedfiles."""
939
 
        return isinstance(source, str) and isinstance(target, str)
940
 
 
941
 
 
942
 
# TODO this and the InterRepository core logic should be consolidatable
943
 
# if we make the registry a separate class though we still need to 
944
 
# test the behaviour in the active registry to catch failure-to-handle-
945
 
# stange-objects
946
 
class TestInterVersionedFile(TestCaseWithMemoryTransport):
947
 
 
948
 
    def test_get_default_inter_versionedfile(self):
949
 
        # test that the InterVersionedFile.get(a, b) probes
950
 
        # for a class where is_compatible(a, b) returns
951
 
        # true and returns a default interversionedfile otherwise.
952
 
        # This also tests that the default registered optimised interversionedfile
953
 
        # classes do not barf inappropriately when a surprising versionedfile type
954
 
        # is handed to them.
955
 
        dummy_a = "VersionedFile 1."
956
 
        dummy_b = "VersionedFile 2."
957
 
        self.assertGetsDefaultInterVersionedFile(dummy_a, dummy_b)
958
 
 
959
 
    def assertGetsDefaultInterVersionedFile(self, a, b):
960
 
        """Asserts that InterVersionedFile.get(a, b) -> the default."""
961
 
        inter = versionedfile.InterVersionedFile.get(a, b)
962
 
        self.assertEqual(versionedfile.InterVersionedFile,
963
 
                         inter.__class__)
964
 
        self.assertEqual(a, inter.source)
965
 
        self.assertEqual(b, inter.target)
966
 
 
967
 
    def test_register_inter_versionedfile_class(self):
968
 
        # test that a optimised code path provider - a
969
 
        # InterVersionedFile subclass can be registered and unregistered
970
 
        # and that it is correctly selected when given a versionedfile
971
 
        # pair that it returns true on for the is_compatible static method
972
 
        # check
973
 
        dummy_a = "VersionedFile 1."
974
 
        dummy_b = "VersionedFile 2."
975
 
        versionedfile.InterVersionedFile.register_optimiser(InterString)
976
 
        try:
977
 
            # we should get the default for something InterString returns False
978
 
            # to
979
 
            self.assertFalse(InterString.is_compatible(dummy_a, None))
980
 
            self.assertGetsDefaultInterVersionedFile(dummy_a, None)
981
 
            # and we should get an InterString for a pair it 'likes'
982
 
            self.assertTrue(InterString.is_compatible(dummy_a, dummy_b))
983
 
            inter = versionedfile.InterVersionedFile.get(dummy_a, dummy_b)
984
 
            self.assertEqual(InterString, inter.__class__)
985
 
            self.assertEqual(dummy_a, inter.source)
986
 
            self.assertEqual(dummy_b, inter.target)
987
 
        finally:
988
 
            versionedfile.InterVersionedFile.unregister_optimiser(InterString)
989
 
        # now we should get the default InterVersionedFile object again.
990
 
        self.assertGetsDefaultInterVersionedFile(dummy_a, dummy_b)
 
841
class TestPlanMergeVersionedFile(TestCaseWithMemoryTransport):
 
842
 
 
843
    def setUp(self):
 
844
        TestCaseWithMemoryTransport.setUp(self)
 
845
        mapper = PrefixMapper()
 
846
        factory = make_file_factory(True, mapper)
 
847
        self.vf1 = factory(self.get_transport('root-1'))
 
848
        self.vf2 = factory(self.get_transport('root-2'))
 
849
        self.plan_merge_vf = versionedfile._PlanMergeVersionedFile('root')
 
850
        self.plan_merge_vf.fallback_versionedfiles.extend([self.vf1, self.vf2])
 
851
 
 
852
    def test_add_lines(self):
 
853
        self.plan_merge_vf.add_lines(('root', 'a:'), [], [])
 
854
        self.assertRaises(ValueError, self.plan_merge_vf.add_lines,
 
855
            ('root', 'a'), [], [])
 
856
        self.assertRaises(ValueError, self.plan_merge_vf.add_lines,
 
857
            ('root', 'a:'), None, [])
 
858
        self.assertRaises(ValueError, self.plan_merge_vf.add_lines,
 
859
            ('root', 'a:'), [], None)
 
860
 
 
861
    def setup_abcde(self):
 
862
        self.vf1.add_lines(('root', 'A'), [], ['a'])
 
863
        self.vf1.add_lines(('root', 'B'), [('root', 'A')], ['b'])
 
864
        self.vf2.add_lines(('root', 'C'), [], ['c'])
 
865
        self.vf2.add_lines(('root', 'D'), [('root', 'C')], ['d'])
 
866
        self.plan_merge_vf.add_lines(('root', 'E:'),
 
867
            [('root', 'B'), ('root', 'D')], ['e'])
 
868
 
 
869
    def test_get_parents(self):
 
870
        self.setup_abcde()
 
871
        self.assertEqual({('root', 'B'):(('root', 'A'),)},
 
872
            self.plan_merge_vf.get_parent_map([('root', 'B')]))
 
873
        self.assertEqual({('root', 'D'):(('root', 'C'),)},
 
874
            self.plan_merge_vf.get_parent_map([('root', 'D')]))
 
875
        self.assertEqual({('root', 'E:'):(('root', 'B'),('root', 'D'))},
 
876
            self.plan_merge_vf.get_parent_map([('root', 'E:')]))
 
877
        self.assertEqual({},
 
878
            self.plan_merge_vf.get_parent_map([('root', 'F')]))
 
879
        self.assertEqual({
 
880
                ('root', 'B'):(('root', 'A'),),
 
881
                ('root', 'D'):(('root', 'C'),),
 
882
                ('root', 'E:'):(('root', 'B'),('root', 'D')),
 
883
                },
 
884
            self.plan_merge_vf.get_parent_map(
 
885
                [('root', 'B'), ('root', 'D'), ('root', 'E:'), ('root', 'F')]))
 
886
 
 
887
    def test_get_record_stream(self):
 
888
        self.setup_abcde()
 
889
        def get_record(suffix):
 
890
            return self.plan_merge_vf.get_record_stream(
 
891
                [('root', suffix)], 'unordered', True).next()
 
892
        self.assertEqual('a', get_record('A').get_bytes_as('fulltext'))
 
893
        self.assertEqual('c', get_record('C').get_bytes_as('fulltext'))
 
894
        self.assertEqual('e', get_record('E:').get_bytes_as('fulltext'))
 
895
        self.assertEqual('absent', get_record('F').storage_kind)
991
896
 
992
897
 
993
898
class TestReadonlyHttpMixin(object):
994
899
 
 
900
    def get_transaction(self):
 
901
        return 1
 
902
 
995
903
    def test_readonly_http_works(self):
996
904
        # we should be able to read from http with a versioned file.
997
905
        vf = self.get_file()
998
906
        # try an empty file access
999
 
        readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
 
907
        readonly_vf = self.get_factory()('foo',
 
908
            transport.get_transport_from_url(self.get_readonly_url('.')))
1000
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()
1001
914
        # now with feeling.
1002
915
        vf.add_lines('1', [], ['a\n'])
1003
916
        vf.add_lines('2', ['1'], ['b\n', 'a\n'])
1004
 
        readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
 
917
        readonly_vf = self.get_factory()('foo',
 
918
            transport.get_transport_from_url(self.get_readonly_url('.')))
1005
919
        self.assertEqual(['1', '2'], vf.versions())
 
920
        self.assertEqual(['1', '2'], readonly_vf.versions())
1006
921
        for version in readonly_vf.versions():
1007
922
            readonly_vf.get_lines(version)
1008
923
 
1010
925
class TestWeaveHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
1011
926
 
1012
927
    def get_file(self):
1013
 
        return WeaveFile('foo', get_transport(self.get_url('.')), create=True)
 
928
        return WeaveFile('foo', self.get_transport(),
 
929
                         create=True,
 
930
                         get_scope=self.get_transaction)
1014
931
 
1015
932
    def get_factory(self):
1016
933
        return WeaveFile
1017
934
 
1018
935
 
1019
 
class TestKnitHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
1020
 
 
1021
 
    def get_file(self):
1022
 
        return KnitVersionedFile('foo', get_transport(self.get_url('.')),
1023
 
                                 delta=True, create=True)
1024
 
 
1025
 
    def get_factory(self):
1026
 
        return KnitVersionedFile
1027
 
 
1028
 
 
1029
936
class MergeCasesMixin(object):
1030
937
 
1031
938
    def doMerge(self, base, a, b, mp):
1034
941
 
1035
942
        def addcrlf(x):
1036
943
            return x + '\n'
1037
 
        
 
944
 
1038
945
        w = self.get_file()
1039
946
        w.add_lines('text0', [], map(addcrlf, base))
1040
947
        w.add_lines('text1', ['text0'], map(addcrlf, a))
1056
963
 
1057
964
        mp = map(addcrlf, mp)
1058
965
        self.assertEqual(mt.readlines(), mp)
1059
 
        
1060
 
        
 
966
 
 
967
 
1061
968
    def testOneInsert(self):
1062
969
        self.doMerge([],
1063
970
                     ['aa'],
1081
988
                     ['aaa', 'xxx', 'yyy', 'bbb'],
1082
989
                     ['aaa', 'xxx', 'bbb'], self.overlappedInsertExpected)
1083
990
 
1084
 
        # really it ought to reduce this to 
 
991
        # really it ought to reduce this to
1085
992
        # ['aaa', 'xxx', 'yyy', 'bbb']
1086
993
 
1087
994
 
1089
996
        self.doMerge(['aaa'],
1090
997
                     ['xxx'],
1091
998
                     ['yyy', 'zzz'],
1092
 
                     ['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz', 
 
999
                     ['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz',
1093
1000
                      '>>>>>>> '])
1094
1001
 
1095
1002
    def testNonClashInsert1(self):
1096
1003
        self.doMerge(['aaa'],
1097
1004
                     ['xxx', 'aaa'],
1098
1005
                     ['yyy', 'zzz'],
1099
 
                     ['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz', 
 
1006
                     ['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz',
1100
1007
                      '>>>>>>> '])
1101
1008
 
1102
1009
    def testNonClashInsert2(self):
1116
1023
        #######################################
1117
1024
        # skippd, not working yet
1118
1025
        return
1119
 
        
 
1026
 
1120
1027
        self.doMerge(['aaa', 'bbb', 'ccc'],
1121
1028
                     ['aaa', 'ddd', 'ccc'],
1122
1029
                     ['aaa', 'ccc'],
1159
1066
            """
1160
1067
        result = """\
1161
1068
            line 1
 
1069
<<<<<<<\x20
 
1070
            line 2
 
1071
=======
 
1072
>>>>>>>\x20
1162
1073
            """
1163
1074
        self._test_merge_from_strings(base, a, b, result)
1164
1075
 
1165
1076
    def test_deletion_overlap(self):
1166
1077
        """Delete overlapping regions with no other conflict.
1167
1078
 
1168
 
        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
1169
1080
        conflict, but for now conflict is safer.
1170
1081
        """
1171
1082
        base = """\
1187
1098
            """
1188
1099
        result = """\
1189
1100
            start context
1190
 
<<<<<<< 
 
1101
<<<<<<<\x20
1191
1102
            int a() {}
1192
1103
=======
1193
1104
            int c() {}
1194
 
>>>>>>> 
 
1105
>>>>>>>\x20
1195
1106
            end context
1196
1107
            """
1197
1108
        self._test_merge_from_strings(base, a, b, result)
1223
1134
 
1224
1135
    def test_sync_on_deletion(self):
1225
1136
        """Specific case of merge where we can synchronize incorrectly.
1226
 
        
 
1137
 
1227
1138
        A previous version of the weave merge concluded that the two versions
1228
1139
        agreed on deleting line 2, and this could be a synchronization point.
1229
 
        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
1230
1141
        both sides.
1231
1142
 
1232
1143
        It's better to consider the whole thing as a disagreement region.
1251
1162
            """
1252
1163
        result = """\
1253
1164
            start context
1254
 
<<<<<<< 
 
1165
<<<<<<<\x20
1255
1166
            base line 1
1256
1167
            a's replacement line 2
1257
1168
=======
1258
1169
            b replaces
1259
1170
            both lines
1260
 
>>>>>>> 
 
1171
>>>>>>>\x20
1261
1172
            end context
1262
1173
            """
1263
1174
        self._test_merge_from_strings(base, a, b, result)
1264
1175
 
1265
1176
 
1266
 
class TestKnitMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1267
 
 
1268
 
    def get_file(self, name='foo'):
1269
 
        return KnitVersionedFile(name, get_transport(self.get_url('.')),
1270
 
                                 delta=True, create=True)
1271
 
 
1272
 
    def log_contents(self, w):
1273
 
        pass
1274
 
 
1275
 
 
1276
1177
class TestWeaveMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1277
1178
 
1278
1179
    def get_file(self, name='foo'):
1279
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
 
1180
        return WeaveFile(name, self.get_transport(),
 
1181
                         create=True)
1280
1182
 
1281
1183
    def log_contents(self, w):
1282
1184
        self.log('weave is:')
1284
1186
        write_weave(w, tmpf)
1285
1187
        self.log(tmpf.getvalue())
1286
1188
 
1287
 
    overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======', 
 
1189
    overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======',
1288
1190
                                'xxx', '>>>>>>> ', 'bbb']
1289
1191
 
1290
1192
 
1291
 
class TestFormatSignatures(TestCaseWithMemoryTransport):
1292
 
 
1293
 
    def get_knit_file(self, name, annotated):
1294
 
        if annotated:
1295
 
            factory = KnitAnnotateFactory()
1296
 
        else:
1297
 
            factory = KnitPlainFactory()
1298
 
        return KnitVersionedFile(
1299
 
            name, get_transport(self.get_url('.')), create=True,
1300
 
            factory=factory)
1301
 
 
1302
 
    def test_knit_format_signatures(self):
1303
 
        """Different formats of knit have different signature strings."""
1304
 
        knit = self.get_knit_file('a', True)
1305
 
        self.assertEqual('knit-annotated', knit.get_format_signature())
1306
 
        knit = self.get_knit_file('p', False)
1307
 
        self.assertEqual('knit-plain', knit.get_format_signature())
1308
 
 
 
1193
class TestContentFactoryAdaption(TestCaseWithMemoryTransport):
 
1194
 
 
1195
    def test_select_adaptor(self):
 
1196
        """Test expected adapters exist."""
 
1197
        # One scenario for each lookup combination we expect to use.
 
1198
        # Each is source_kind, requested_kind, adapter class
 
1199
        scenarios = [
 
1200
            ('knit-delta-gz', 'fulltext', _mod_knit.DeltaPlainToFullText),
 
1201
            ('knit-ft-gz', 'fulltext', _mod_knit.FTPlainToFullText),
 
1202
            ('knit-annotated-delta-gz', 'knit-delta-gz',
 
1203
                _mod_knit.DeltaAnnotatedToUnannotated),
 
1204
            ('knit-annotated-delta-gz', 'fulltext',
 
1205
                _mod_knit.DeltaAnnotatedToFullText),
 
1206
            ('knit-annotated-ft-gz', 'knit-ft-gz',
 
1207
                _mod_knit.FTAnnotatedToUnannotated),
 
1208
            ('knit-annotated-ft-gz', 'fulltext',
 
1209
                _mod_knit.FTAnnotatedToFullText),
 
1210
            ]
 
1211
        for source, requested, klass in scenarios:
 
1212
            adapter_factory = versionedfile.adapter_registry.get(
 
1213
                (source, requested))
 
1214
            adapter = adapter_factory(None)
 
1215
            self.assertIsInstance(adapter, klass)
 
1216
 
 
1217
    def get_knit(self, annotated=True):
 
1218
        mapper = ConstantMapper('knit')
 
1219
        transport = self.get_transport()
 
1220
        return make_file_factory(annotated, mapper)(transport)
 
1221
 
 
1222
    def helpGetBytes(self, f, ft_adapter, delta_adapter):
 
1223
        """Grab the interested adapted texts for tests."""
 
1224
        # origin is a fulltext
 
1225
        entries = f.get_record_stream([('origin',)], 'unordered', False)
 
1226
        base = entries.next()
 
1227
        ft_data = ft_adapter.get_bytes(base)
 
1228
        # merged is both a delta and multiple parents.
 
1229
        entries = f.get_record_stream([('merged',)], 'unordered', False)
 
1230
        merged = entries.next()
 
1231
        delta_data = delta_adapter.get_bytes(merged)
 
1232
        return ft_data, delta_data
 
1233
 
 
1234
    def test_deannotation_noeol(self):
 
1235
        """Test converting annotated knits to unannotated knits."""
 
1236
        # we need a full text, and a delta
 
1237
        f = self.get_knit()
 
1238
        get_diamond_files(f, 1, trailing_eol=False)
 
1239
        ft_data, delta_data = self.helpGetBytes(f,
 
1240
            _mod_knit.FTAnnotatedToUnannotated(None),
 
1241
            _mod_knit.DeltaAnnotatedToUnannotated(None))
 
1242
        self.assertEqual(
 
1243
            'version origin 1 b284f94827db1fa2970d9e2014f080413b547a7e\n'
 
1244
            'origin\n'
 
1245
            'end origin\n',
 
1246
            GzipFile(mode='rb', fileobj=StringIO(ft_data)).read())
 
1247
        self.assertEqual(
 
1248
            'version merged 4 32c2e79763b3f90e8ccde37f9710b6629c25a796\n'
 
1249
            '1,2,3\nleft\nright\nmerged\nend merged\n',
 
1250
            GzipFile(mode='rb', fileobj=StringIO(delta_data)).read())
 
1251
 
 
1252
    def test_deannotation(self):
 
1253
        """Test converting annotated knits to unannotated knits."""
 
1254
        # we need a full text, and a delta
 
1255
        f = self.get_knit()
 
1256
        get_diamond_files(f, 1)
 
1257
        ft_data, delta_data = self.helpGetBytes(f,
 
1258
            _mod_knit.FTAnnotatedToUnannotated(None),
 
1259
            _mod_knit.DeltaAnnotatedToUnannotated(None))
 
1260
        self.assertEqual(
 
1261
            'version origin 1 00e364d235126be43292ab09cb4686cf703ddc17\n'
 
1262
            'origin\n'
 
1263
            'end origin\n',
 
1264
            GzipFile(mode='rb', fileobj=StringIO(ft_data)).read())
 
1265
        self.assertEqual(
 
1266
            'version merged 3 ed8bce375198ea62444dc71952b22cfc2b09226d\n'
 
1267
            '2,2,2\nright\nmerged\nend merged\n',
 
1268
            GzipFile(mode='rb', fileobj=StringIO(delta_data)).read())
 
1269
 
 
1270
    def test_annotated_to_fulltext_no_eol(self):
 
1271
        """Test adapting annotated knits to full texts (for -> weaves)."""
 
1272
        # we need a full text, and a delta
 
1273
        f = self.get_knit()
 
1274
        get_diamond_files(f, 1, trailing_eol=False)
 
1275
        # Reconstructing a full text requires a backing versioned file, and it
 
1276
        # must have the base lines requested from it.
 
1277
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
 
1278
        ft_data, delta_data = self.helpGetBytes(f,
 
1279
            _mod_knit.FTAnnotatedToFullText(None),
 
1280
            _mod_knit.DeltaAnnotatedToFullText(logged_vf))
 
1281
        self.assertEqual('origin', ft_data)
 
1282
        self.assertEqual('base\nleft\nright\nmerged', delta_data)
 
1283
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
 
1284
            True)], logged_vf.calls)
 
1285
 
 
1286
    def test_annotated_to_fulltext(self):
 
1287
        """Test adapting annotated knits to full texts (for -> weaves)."""
 
1288
        # we need a full text, and a delta
 
1289
        f = self.get_knit()
 
1290
        get_diamond_files(f, 1)
 
1291
        # Reconstructing a full text requires a backing versioned file, and it
 
1292
        # must have the base lines requested from it.
 
1293
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
 
1294
        ft_data, delta_data = self.helpGetBytes(f,
 
1295
            _mod_knit.FTAnnotatedToFullText(None),
 
1296
            _mod_knit.DeltaAnnotatedToFullText(logged_vf))
 
1297
        self.assertEqual('origin\n', ft_data)
 
1298
        self.assertEqual('base\nleft\nright\nmerged\n', delta_data)
 
1299
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
 
1300
            True)], logged_vf.calls)
 
1301
 
 
1302
    def test_unannotated_to_fulltext(self):
 
1303
        """Test adapting unannotated knits to full texts.
 
1304
 
 
1305
        This is used for -> weaves, and for -> annotated knits.
 
1306
        """
 
1307
        # we need a full text, and a delta
 
1308
        f = self.get_knit(annotated=False)
 
1309
        get_diamond_files(f, 1)
 
1310
        # Reconstructing a full text requires a backing versioned file, and it
 
1311
        # must have the base lines requested from it.
 
1312
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
 
1313
        ft_data, delta_data = self.helpGetBytes(f,
 
1314
            _mod_knit.FTPlainToFullText(None),
 
1315
            _mod_knit.DeltaPlainToFullText(logged_vf))
 
1316
        self.assertEqual('origin\n', ft_data)
 
1317
        self.assertEqual('base\nleft\nright\nmerged\n', delta_data)
 
1318
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
 
1319
            True)], logged_vf.calls)
 
1320
 
 
1321
    def test_unannotated_to_fulltext_no_eol(self):
 
1322
        """Test adapting unannotated knits to full texts.
 
1323
 
 
1324
        This is used for -> weaves, and for -> annotated knits.
 
1325
        """
 
1326
        # we need a full text, and a delta
 
1327
        f = self.get_knit(annotated=False)
 
1328
        get_diamond_files(f, 1, trailing_eol=False)
 
1329
        # Reconstructing a full text requires a backing versioned file, and it
 
1330
        # must have the base lines requested from it.
 
1331
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
 
1332
        ft_data, delta_data = self.helpGetBytes(f,
 
1333
            _mod_knit.FTPlainToFullText(None),
 
1334
            _mod_knit.DeltaPlainToFullText(logged_vf))
 
1335
        self.assertEqual('origin', ft_data)
 
1336
        self.assertEqual('base\nleft\nright\nmerged', delta_data)
 
1337
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
 
1338
            True)], logged_vf.calls)
 
1339
 
 
1340
 
 
1341
class TestKeyMapper(TestCaseWithMemoryTransport):
 
1342
    """Tests for various key mapping logic."""
 
1343
 
 
1344
    def test_identity_mapper(self):
 
1345
        mapper = versionedfile.ConstantMapper("inventory")
 
1346
        self.assertEqual("inventory", mapper.map(('foo@ar',)))
 
1347
        self.assertEqual("inventory", mapper.map(('quux',)))
 
1348
 
 
1349
    def test_prefix_mapper(self):
 
1350
        #format5: plain
 
1351
        mapper = versionedfile.PrefixMapper()
 
1352
        self.assertEqual("file-id", mapper.map(("file-id", "revision-id")))
 
1353
        self.assertEqual("new-id", mapper.map(("new-id", "revision-id")))
 
1354
        self.assertEqual(('file-id',), mapper.unmap("file-id"))
 
1355
        self.assertEqual(('new-id',), mapper.unmap("new-id"))
 
1356
 
 
1357
    def test_hash_prefix_mapper(self):
 
1358
        #format6: hash + plain
 
1359
        mapper = versionedfile.HashPrefixMapper()
 
1360
        self.assertEqual("9b/file-id", mapper.map(("file-id", "revision-id")))
 
1361
        self.assertEqual("45/new-id", mapper.map(("new-id", "revision-id")))
 
1362
        self.assertEqual(('file-id',), mapper.unmap("9b/file-id"))
 
1363
        self.assertEqual(('new-id',), mapper.unmap("45/new-id"))
 
1364
 
 
1365
    def test_hash_escaped_mapper(self):
 
1366
        #knit1: hash + escaped
 
1367
        mapper = versionedfile.HashEscapedPrefixMapper()
 
1368
        self.assertEqual("88/%2520", mapper.map((" ", "revision-id")))
 
1369
        self.assertEqual("ed/fil%2545-%2549d", mapper.map(("filE-Id",
 
1370
            "revision-id")))
 
1371
        self.assertEqual("88/ne%2557-%2549d", mapper.map(("neW-Id",
 
1372
            "revision-id")))
 
1373
        self.assertEqual(('filE-Id',), mapper.unmap("ed/fil%2545-%2549d"))
 
1374
        self.assertEqual(('neW-Id',), mapper.unmap("88/ne%2557-%2549d"))
 
1375
 
 
1376
 
 
1377
class TestVersionedFiles(TestCaseWithMemoryTransport):
 
1378
    """Tests for the multiple-file variant of VersionedFile."""
 
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
 
 
1469
    def get_versionedfiles(self, relpath='files'):
 
1470
        transport = self.get_transport(relpath)
 
1471
        if relpath != '.':
 
1472
            transport.mkdir('.')
 
1473
        files = self.factory(transport)
 
1474
        if self.cleanup is not None:
 
1475
            self.addCleanup(self.cleanup, files)
 
1476
        return files
 
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
 
 
1537
    def test_annotate(self):
 
1538
        files = self.get_versionedfiles()
 
1539
        self.get_diamond_files(files)
 
1540
        if self.key_length == 1:
 
1541
            prefix = ()
 
1542
        else:
 
1543
            prefix = ('FileA',)
 
1544
        # introduced full text
 
1545
        origins = files.annotate(prefix + ('origin',))
 
1546
        self.assertEqual([
 
1547
            (prefix + ('origin',), 'origin\n')],
 
1548
            origins)
 
1549
        # a delta
 
1550
        origins = files.annotate(prefix + ('base',))
 
1551
        self.assertEqual([
 
1552
            (prefix + ('base',), 'base\n')],
 
1553
            origins)
 
1554
        # a merge
 
1555
        origins = files.annotate(prefix + ('merged',))
 
1556
        if self.graph:
 
1557
            self.assertEqual([
 
1558
                (prefix + ('base',), 'base\n'),
 
1559
                (prefix + ('left',), 'left\n'),
 
1560
                (prefix + ('right',), 'right\n'),
 
1561
                (prefix + ('merged',), 'merged\n')
 
1562
                ],
 
1563
                origins)
 
1564
        else:
 
1565
            # Without a graph everything is new.
 
1566
            self.assertEqual([
 
1567
                (prefix + ('merged',), 'base\n'),
 
1568
                (prefix + ('merged',), 'left\n'),
 
1569
                (prefix + ('merged',), 'right\n'),
 
1570
                (prefix + ('merged',), 'merged\n')
 
1571
                ],
 
1572
                origins)
 
1573
        self.assertRaises(RevisionNotPresent,
 
1574
            files.annotate, prefix + ('missing-key',))
 
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
 
 
1602
    def test_construct(self):
 
1603
        """Each parameterised test can be constructed on a transport."""
 
1604
        files = self.get_versionedfiles()
 
1605
 
 
1606
    def get_diamond_files(self, files, trailing_eol=True, left_only=False,
 
1607
        nokeys=False):
 
1608
        return get_diamond_files(files, self.key_length,
 
1609
            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)
 
1646
 
 
1647
    def test_add_lines_return(self):
 
1648
        files = self.get_versionedfiles()
 
1649
        # save code by using the stock data insertion helper.
 
1650
        adds = self.get_diamond_files(files)
 
1651
        results = []
 
1652
        # We can only validate the first 2 elements returned from add_lines.
 
1653
        for add in adds:
 
1654
            self.assertEqual(3, len(add))
 
1655
            results.append(add[:2])
 
1656
        if self.key_length == 1:
 
1657
            self.assertEqual([
 
1658
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
 
1659
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
 
1660
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
 
1661
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
 
1662
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
 
1663
                results)
 
1664
        elif self.key_length == 2:
 
1665
            self.assertEqual([
 
1666
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
 
1667
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
 
1668
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
 
1669
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
 
1670
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
 
1671
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
 
1672
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
 
1673
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
 
1674
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23),
 
1675
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
 
1676
                results)
 
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
 
 
1732
    def test_empty_lines(self):
 
1733
        """Empty files can be stored."""
 
1734
        f = self.get_versionedfiles()
 
1735
        key_a = self.get_simple_key('a')
 
1736
        f.add_lines(key_a, [], [])
 
1737
        self.assertEqual('',
 
1738
            f.get_record_stream([key_a], 'unordered', True
 
1739
                ).next().get_bytes_as('fulltext'))
 
1740
        key_b = self.get_simple_key('b')
 
1741
        f.add_lines(key_b, self.get_parents([key_a]), [])
 
1742
        self.assertEqual('',
 
1743
            f.get_record_stream([key_b], 'unordered', True
 
1744
                ).next().get_bytes_as('fulltext'))
 
1745
 
 
1746
    def test_newline_only(self):
 
1747
        f = self.get_versionedfiles()
 
1748
        key_a = self.get_simple_key('a')
 
1749
        f.add_lines(key_a, [], ['\n'])
 
1750
        self.assertEqual('\n',
 
1751
            f.get_record_stream([key_a], 'unordered', True
 
1752
                ).next().get_bytes_as('fulltext'))
 
1753
        key_b = self.get_simple_key('b')
 
1754
        f.add_lines(key_b, self.get_parents([key_a]), ['\n'])
 
1755
        self.assertEqual('\n',
 
1756
            f.get_record_stream([key_b], 'unordered', True
 
1757
                ).next().get_bytes_as('fulltext'))
 
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
 
 
1801
    def test_get_record_stream_empty(self):
 
1802
        """An empty stream can be requested without error."""
 
1803
        f = self.get_versionedfiles()
 
1804
        entries = f.get_record_stream([], 'unordered', False)
 
1805
        self.assertEqual([], list(entries))
 
1806
 
 
1807
    def assertValidStorageKind(self, storage_kind):
 
1808
        """Assert that storage_kind is a valid storage_kind."""
 
1809
        self.assertSubset([storage_kind],
 
1810
            ['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'])
 
1816
 
 
1817
    def capture_stream(self, f, entries, on_seen, parents,
 
1818
        require_fulltext=False):
 
1819
        """Capture a stream for testing."""
 
1820
        for factory in entries:
 
1821
            on_seen(factory.key)
 
1822
            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)
 
1826
            self.assertEqual(parents[factory.key], factory.parents)
 
1827
            self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
 
1828
                str)
 
1829
            if require_fulltext:
 
1830
                factory.get_bytes_as('fulltext')
 
1831
 
 
1832
    def test_get_record_stream_interface(self):
 
1833
        """each item in a stream has to provide a regular interface."""
 
1834
        files = self.get_versionedfiles()
 
1835
        self.get_diamond_files(files)
 
1836
        keys, _ = self.get_keys_and_sort_order()
 
1837
        parent_map = files.get_parent_map(keys)
 
1838
        entries = files.get_record_stream(keys, 'unordered', False)
 
1839
        seen = set()
 
1840
        self.capture_stream(files, entries, seen.add, parent_map)
 
1841
        self.assertEqual(set(keys), seen)
 
1842
 
 
1843
    def get_keys_and_sort_order(self):
 
1844
        """Get diamond test keys list, and their sort ordering."""
 
1845
        if self.key_length == 1:
 
1846
            keys = [('merged',), ('left',), ('right',), ('base',)]
 
1847
            sort_order = {('merged',):2, ('left',):1, ('right',):1, ('base',):0}
 
1848
        else:
 
1849
            keys = [
 
1850
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
 
1851
                ('FileA', 'base'),
 
1852
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
 
1853
                ('FileB', 'base'),
 
1854
                ]
 
1855
            sort_order = {
 
1856
                ('FileA', 'merged'):2, ('FileA', 'left'):1, ('FileA', 'right'):1,
 
1857
                ('FileA', 'base'):0,
 
1858
                ('FileB', 'merged'):2, ('FileB', 'left'):1, ('FileB', 'right'):1,
 
1859
                ('FileB', 'base'):0,
 
1860
                }
 
1861
        return keys, sort_order
 
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
 
 
1883
    def test_get_record_stream_interface_ordered(self):
 
1884
        """each item in a stream has to provide a regular interface."""
 
1885
        files = self.get_versionedfiles()
 
1886
        self.get_diamond_files(files)
 
1887
        keys, sort_order = self.get_keys_and_sort_order()
 
1888
        parent_map = files.get_parent_map(keys)
 
1889
        entries = files.get_record_stream(keys, 'topological', False)
 
1890
        seen = []
 
1891
        self.capture_stream(files, entries, seen.append, parent_map)
 
1892
        self.assertStreamOrder(sort_order, seen, keys)
 
1893
 
 
1894
    def test_get_record_stream_interface_ordered_with_delta_closure(self):
 
1895
        """each item must be accessible as a fulltext."""
 
1896
        files = self.get_versionedfiles()
 
1897
        self.get_diamond_files(files)
 
1898
        keys, sort_order = self.get_keys_and_sort_order()
 
1899
        parent_map = files.get_parent_map(keys)
 
1900
        entries = files.get_record_stream(keys, 'topological', True)
 
1901
        seen = []
 
1902
        for factory in entries:
 
1903
            seen.append(factory.key)
 
1904
            self.assertValidStorageKind(factory.storage_kind)
 
1905
            self.assertSubset([factory.sha1],
 
1906
                [None, files.get_sha1s([factory.key])[factory.key]])
 
1907
            self.assertEqual(parent_map[factory.key], factory.parents)
 
1908
            # 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)
 
1925
        self.assertStreamOrder(sort_order, seen, keys)
 
1926
 
 
1927
    def assertStreamOrder(self, sort_order, seen, keys):
 
1928
        self.assertEqual(len(set(seen)), len(keys))
 
1929
        if self.key_length == 1:
 
1930
            lows = {():0}
 
1931
        else:
 
1932
            lows = {('FileA',):0, ('FileB',):0}
 
1933
        if not self.graph:
 
1934
            self.assertEqual(set(keys), set(seen))
 
1935
        else:
 
1936
            for key in seen:
 
1937
                sort_pos = sort_order[key]
 
1938
                self.assertTrue(sort_pos >= lows[key[:-1]],
 
1939
                    "Out of order in sorted stream: %r, %r" % (key, seen))
 
1940
                lows[key[:-1]] = sort_pos
 
1941
 
 
1942
    def test_get_record_stream_unknown_storage_kind_raises(self):
 
1943
        """Asking for a storage kind that the stream cannot supply raises."""
 
1944
        files = self.get_versionedfiles()
 
1945
        self.get_diamond_files(files)
 
1946
        if self.key_length == 1:
 
1947
            keys = [('merged',), ('left',), ('right',), ('base',)]
 
1948
        else:
 
1949
            keys = [
 
1950
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
 
1951
                ('FileA', 'base'),
 
1952
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
 
1953
                ('FileB', 'base'),
 
1954
                ]
 
1955
        parent_map = files.get_parent_map(keys)
 
1956
        entries = files.get_record_stream(keys, 'unordered', False)
 
1957
        # We track the contents because we should be able to try, fail a
 
1958
        # particular kind and then ask for one that works and continue.
 
1959
        seen = set()
 
1960
        for factory in entries:
 
1961
            seen.add(factory.key)
 
1962
            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)
 
1966
            self.assertEqual(parent_map[factory.key], factory.parents)
 
1967
            # currently no stream emits mpdiff
 
1968
            self.assertRaises(errors.UnavailableRepresentation,
 
1969
                factory.get_bytes_as, 'mpdiff')
 
1970
            self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
 
1971
                str)
 
1972
        self.assertEqual(set(keys), seen)
 
1973
 
 
1974
    def test_get_record_stream_missing_records_are_absent(self):
 
1975
        files = self.get_versionedfiles()
 
1976
        self.get_diamond_files(files)
 
1977
        if self.key_length == 1:
 
1978
            keys = [('merged',), ('left',), ('right',), ('absent',), ('base',)]
 
1979
        else:
 
1980
            keys = [
 
1981
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
 
1982
                ('FileA', 'absent'), ('FileA', 'base'),
 
1983
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
 
1984
                ('FileB', 'absent'), ('FileB', 'base'),
 
1985
                ('absent', 'absent'),
 
1986
                ]
 
1987
        parent_map = files.get_parent_map(keys)
 
1988
        entries = files.get_record_stream(keys, 'unordered', False)
 
1989
        self.assertAbsentRecord(files, keys, parent_map, entries)
 
1990
        entries = files.get_record_stream(keys, 'topological', False)
 
1991
        self.assertAbsentRecord(files, keys, parent_map, entries)
 
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
 
 
2158
    def assertAbsentRecord(self, files, keys, parents, entries):
 
2159
        """Helper for test_get_record_stream_missing_records_are_absent."""
 
2160
        seen = set()
 
2161
        for factory in entries:
 
2162
            seen.add(factory.key)
 
2163
            if factory.key[-1] == 'absent':
 
2164
                self.assertEqual('absent', factory.storage_kind)
 
2165
                self.assertEqual(None, factory.sha1)
 
2166
                self.assertEqual(None, factory.parents)
 
2167
            else:
 
2168
                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)
 
2172
                self.assertEqual(parents[factory.key], factory.parents)
 
2173
                self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
 
2174
                    str)
 
2175
        self.assertEqual(set(keys), seen)
 
2176
 
 
2177
    def test_filter_absent_records(self):
 
2178
        """Requested missing records can be filter trivially."""
 
2179
        files = self.get_versionedfiles()
 
2180
        self.get_diamond_files(files)
 
2181
        keys, _ = self.get_keys_and_sort_order()
 
2182
        parent_map = files.get_parent_map(keys)
 
2183
        # Add an absent record in the middle of the present keys. (We don't ask
 
2184
        # for just absent keys to ensure that content before and after the
 
2185
        # absent keys is still delivered).
 
2186
        present_keys = list(keys)
 
2187
        if self.key_length == 1:
 
2188
            keys.insert(2, ('extra',))
 
2189
        else:
 
2190
            keys.insert(2, ('extra', 'extra'))
 
2191
        entries = files.get_record_stream(keys, 'unordered', False)
 
2192
        seen = set()
 
2193
        self.capture_stream(files, versionedfile.filter_absent(entries), seen.add,
 
2194
            parent_map)
 
2195
        self.assertEqual(set(present_keys), seen)
 
2196
 
 
2197
    def get_mapper(self):
 
2198
        """Get a mapper suitable for the key length of the test interface."""
 
2199
        if self.key_length == 1:
 
2200
            return ConstantMapper('source')
 
2201
        else:
 
2202
            return HashEscapedPrefixMapper()
 
2203
 
 
2204
    def get_parents(self, parents):
 
2205
        """Get parents, taking self.graph into consideration."""
 
2206
        if self.graph:
 
2207
            return parents
 
2208
        else:
 
2209
            return None
 
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
 
 
2247
    def test_get_parent_map(self):
 
2248
        files = self.get_versionedfiles()
 
2249
        if self.key_length == 1:
 
2250
            parent_details = [
 
2251
                (('r0',), self.get_parents(())),
 
2252
                (('r1',), self.get_parents((('r0',),))),
 
2253
                (('r2',), self.get_parents(())),
 
2254
                (('r3',), self.get_parents(())),
 
2255
                (('m',), self.get_parents((('r0',),('r1',),('r2',),('r3',)))),
 
2256
                ]
 
2257
        else:
 
2258
            parent_details = [
 
2259
                (('FileA', 'r0'), self.get_parents(())),
 
2260
                (('FileA', 'r1'), self.get_parents((('FileA', 'r0'),))),
 
2261
                (('FileA', 'r2'), self.get_parents(())),
 
2262
                (('FileA', 'r3'), self.get_parents(())),
 
2263
                (('FileA', 'm'), self.get_parents((('FileA', 'r0'),
 
2264
                    ('FileA', 'r1'), ('FileA', 'r2'), ('FileA', 'r3')))),
 
2265
                ]
 
2266
        for key, parents in parent_details:
 
2267
            files.add_lines(key, parents, [])
 
2268
            # immediately after adding it should be queryable.
 
2269
            self.assertEqual({key:parents}, files.get_parent_map([key]))
 
2270
        # We can ask for an empty set
 
2271
        self.assertEqual({}, files.get_parent_map([]))
 
2272
        # We can ask for many keys
 
2273
        all_parents = dict(parent_details)
 
2274
        self.assertEqual(all_parents, files.get_parent_map(all_parents.keys()))
 
2275
        # Absent keys are just not included in the result.
 
2276
        keys = all_parents.keys()
 
2277
        if self.key_length == 1:
 
2278
            keys.insert(1, ('missing',))
 
2279
        else:
 
2280
            keys.insert(1, ('missing', 'missing'))
 
2281
        # Absent keys are just ignored
 
2282
        self.assertEqual(all_parents, files.get_parent_map(keys))
 
2283
 
 
2284
    def test_get_sha1s(self):
 
2285
        files = self.get_versionedfiles()
 
2286
        self.get_diamond_files(files)
 
2287
        if self.key_length == 1:
 
2288
            keys = [('base',), ('origin',), ('left',), ('merged',), ('right',)]
 
2289
        else:
 
2290
            # ask for shas from different prefixes.
 
2291
            keys = [
 
2292
                ('FileA', 'base'), ('FileB', 'origin'), ('FileA', 'left'),
 
2293
                ('FileA', 'merged'), ('FileB', 'right'),
 
2294
                ]
 
2295
        self.assertEqual({
 
2296
            keys[0]: '51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44',
 
2297
            keys[1]: '00e364d235126be43292ab09cb4686cf703ddc17',
 
2298
            keys[2]: 'a8478686da38e370e32e42e8a0c220e33ee9132f',
 
2299
            keys[3]: 'ed8bce375198ea62444dc71952b22cfc2b09226d',
 
2300
            keys[4]: '9ef09dfa9d86780bdec9219a22560c6ece8e0ef1',
 
2301
            },
 
2302
            files.get_sha1s(keys))
 
2303
 
 
2304
    def test_insert_record_stream_empty(self):
 
2305
        """Inserting an empty record stream should work."""
 
2306
        files = self.get_versionedfiles()
 
2307
        files.insert_record_stream([])
 
2308
 
 
2309
    def assertIdenticalVersionedFile(self, expected, actual):
 
2310
        """Assert that left and right have the same contents."""
 
2311
        self.assertEqual(set(actual.keys()), set(expected.keys()))
 
2312
        actual_parents = actual.get_parent_map(actual.keys())
 
2313
        if self.graph:
 
2314
            self.assertEqual(actual_parents, expected.get_parent_map(expected.keys()))
 
2315
        else:
 
2316
            for key, parents in actual_parents.items():
 
2317
                self.assertEqual(None, parents)
 
2318
        for key in actual.keys():
 
2319
            actual_text = actual.get_record_stream(
 
2320
                [key], 'unordered', True).next().get_bytes_as('fulltext')
 
2321
            expected_text = expected.get_record_stream(
 
2322
                [key], 'unordered', True).next().get_bytes_as('fulltext')
 
2323
            self.assertEqual(actual_text, expected_text)
 
2324
 
 
2325
    def test_insert_record_stream_fulltexts(self):
 
2326
        """Any file should accept a stream of fulltexts."""
 
2327
        files = self.get_versionedfiles()
 
2328
        mapper = self.get_mapper()
 
2329
        source_transport = self.get_transport('source')
 
2330
        source_transport.mkdir('.')
 
2331
        # weaves always output fulltexts.
 
2332
        source = make_versioned_files_factory(WeaveFile, mapper)(
 
2333
            source_transport)
 
2334
        self.get_diamond_files(source, trailing_eol=False)
 
2335
        stream = source.get_record_stream(source.keys(), 'topological',
 
2336
            False)
 
2337
        files.insert_record_stream(stream)
 
2338
        self.assertIdenticalVersionedFile(source, files)
 
2339
 
 
2340
    def test_insert_record_stream_fulltexts_noeol(self):
 
2341
        """Any file should accept a stream of fulltexts."""
 
2342
        files = self.get_versionedfiles()
 
2343
        mapper = self.get_mapper()
 
2344
        source_transport = self.get_transport('source')
 
2345
        source_transport.mkdir('.')
 
2346
        # weaves always output fulltexts.
 
2347
        source = make_versioned_files_factory(WeaveFile, mapper)(
 
2348
            source_transport)
 
2349
        self.get_diamond_files(source, trailing_eol=False)
 
2350
        stream = source.get_record_stream(source.keys(), 'topological',
 
2351
            False)
 
2352
        files.insert_record_stream(stream)
 
2353
        self.assertIdenticalVersionedFile(source, files)
 
2354
 
 
2355
    def test_insert_record_stream_annotated_knits(self):
 
2356
        """Any file should accept a stream from plain knits."""
 
2357
        files = self.get_versionedfiles()
 
2358
        mapper = self.get_mapper()
 
2359
        source_transport = self.get_transport('source')
 
2360
        source_transport.mkdir('.')
 
2361
        source = make_file_factory(True, mapper)(source_transport)
 
2362
        self.get_diamond_files(source)
 
2363
        stream = source.get_record_stream(source.keys(), 'topological',
 
2364
            False)
 
2365
        files.insert_record_stream(stream)
 
2366
        self.assertIdenticalVersionedFile(source, files)
 
2367
 
 
2368
    def test_insert_record_stream_annotated_knits_noeol(self):
 
2369
        """Any file should accept a stream from plain knits."""
 
2370
        files = self.get_versionedfiles()
 
2371
        mapper = self.get_mapper()
 
2372
        source_transport = self.get_transport('source')
 
2373
        source_transport.mkdir('.')
 
2374
        source = make_file_factory(True, mapper)(source_transport)
 
2375
        self.get_diamond_files(source, trailing_eol=False)
 
2376
        stream = source.get_record_stream(source.keys(), 'topological',
 
2377
            False)
 
2378
        files.insert_record_stream(stream)
 
2379
        self.assertIdenticalVersionedFile(source, files)
 
2380
 
 
2381
    def test_insert_record_stream_plain_knits(self):
 
2382
        """Any file should accept a stream from plain knits."""
 
2383
        files = self.get_versionedfiles()
 
2384
        mapper = self.get_mapper()
 
2385
        source_transport = self.get_transport('source')
 
2386
        source_transport.mkdir('.')
 
2387
        source = make_file_factory(False, mapper)(source_transport)
 
2388
        self.get_diamond_files(source)
 
2389
        stream = source.get_record_stream(source.keys(), 'topological',
 
2390
            False)
 
2391
        files.insert_record_stream(stream)
 
2392
        self.assertIdenticalVersionedFile(source, files)
 
2393
 
 
2394
    def test_insert_record_stream_plain_knits_noeol(self):
 
2395
        """Any file should accept a stream from plain knits."""
 
2396
        files = self.get_versionedfiles()
 
2397
        mapper = self.get_mapper()
 
2398
        source_transport = self.get_transport('source')
 
2399
        source_transport.mkdir('.')
 
2400
        source = make_file_factory(False, mapper)(source_transport)
 
2401
        self.get_diamond_files(source, trailing_eol=False)
 
2402
        stream = source.get_record_stream(source.keys(), 'topological',
 
2403
            False)
 
2404
        files.insert_record_stream(stream)
 
2405
        self.assertIdenticalVersionedFile(source, files)
 
2406
 
 
2407
    def test_insert_record_stream_existing_keys(self):
 
2408
        """Inserting keys already in a file should not error."""
 
2409
        files = self.get_versionedfiles()
 
2410
        source = self.get_versionedfiles('source')
 
2411
        self.get_diamond_files(source)
 
2412
        # insert some keys into f.
 
2413
        self.get_diamond_files(files, left_only=True)
 
2414
        stream = source.get_record_stream(source.keys(), 'topological',
 
2415
            False)
 
2416
        files.insert_record_stream(stream)
 
2417
        self.assertIdenticalVersionedFile(source, files)
 
2418
 
 
2419
    def test_insert_record_stream_missing_keys(self):
 
2420
        """Inserting a stream with absent keys should raise an error."""
 
2421
        files = self.get_versionedfiles()
 
2422
        source = self.get_versionedfiles('source')
 
2423
        stream = source.get_record_stream([('missing',) * self.key_length],
 
2424
            'topological', False)
 
2425
        self.assertRaises(errors.RevisionNotPresent, files.insert_record_stream,
 
2426
            stream)
 
2427
 
 
2428
    def test_insert_record_stream_out_of_order(self):
 
2429
        """An out of order stream can either error or work."""
 
2430
        files = self.get_versionedfiles()
 
2431
        source = self.get_versionedfiles('source')
 
2432
        self.get_diamond_files(source)
 
2433
        if self.key_length == 1:
 
2434
            origin_keys = [('origin',)]
 
2435
            end_keys = [('merged',), ('left',)]
 
2436
            start_keys = [('right',), ('base',)]
 
2437
        else:
 
2438
            origin_keys = [('FileA', 'origin'), ('FileB', 'origin')]
 
2439
            end_keys = [('FileA', 'merged',), ('FileA', 'left',),
 
2440
                ('FileB', 'merged',), ('FileB', 'left',)]
 
2441
            start_keys = [('FileA', 'right',), ('FileA', 'base',),
 
2442
                ('FileB', 'right',), ('FileB', 'base',)]
 
2443
        origin_entries = source.get_record_stream(origin_keys, 'unordered', False)
 
2444
        end_entries = source.get_record_stream(end_keys, 'topological', False)
 
2445
        start_entries = source.get_record_stream(start_keys, 'topological', False)
 
2446
        entries = chain(origin_entries, end_entries, start_entries)
 
2447
        try:
 
2448
            files.insert_record_stream(entries)
 
2449
        except RevisionNotPresent:
 
2450
            # Must not have corrupted the file.
 
2451
            files.check()
 
2452
        else:
 
2453
            self.assertIdenticalVersionedFile(source, files)
 
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
 
 
2504
    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())
 
2557
        files.check()
 
2558
 
 
2559
    def test_iter_lines_added_or_present_in_keys(self):
 
2560
        # test that we get at least an equalset of the lines added by
 
2561
        # versions in the store.
 
2562
        # the ordering here is to make a tree so that dumb searches have
 
2563
        # more changes to muck up.
 
2564
 
 
2565
        class InstrumentedProgress(progress.ProgressTask):
 
2566
 
 
2567
            def __init__(self):
 
2568
                progress.ProgressTask.__init__(self)
 
2569
                self.updates = []
 
2570
 
 
2571
            def update(self, msg=None, current=None, total=None):
 
2572
                self.updates.append((msg, current, total))
 
2573
 
 
2574
        files = self.get_versionedfiles()
 
2575
        # add a base to get included
 
2576
        files.add_lines(self.get_simple_key('base'), (), ['base\n'])
 
2577
        # add a ancestor to be included on one side
 
2578
        files.add_lines(self.get_simple_key('lancestor'), (), ['lancestor\n'])
 
2579
        # add a ancestor to be included on the other side
 
2580
        files.add_lines(self.get_simple_key('rancestor'),
 
2581
            self.get_parents([self.get_simple_key('base')]), ['rancestor\n'])
 
2582
        # add a child of rancestor with no eofile-nl
 
2583
        files.add_lines(self.get_simple_key('child'),
 
2584
            self.get_parents([self.get_simple_key('rancestor')]),
 
2585
            ['base\n', 'child\n'])
 
2586
        # add a child of lancestor and base to join the two roots
 
2587
        files.add_lines(self.get_simple_key('otherchild'),
 
2588
            self.get_parents([self.get_simple_key('lancestor'),
 
2589
                self.get_simple_key('base')]),
 
2590
            ['base\n', 'lancestor\n', 'otherchild\n'])
 
2591
        def iter_with_keys(keys, expected):
 
2592
            # now we need to see what lines are returned, and how often.
 
2593
            lines = {}
 
2594
            progress = InstrumentedProgress()
 
2595
            # iterate over the lines
 
2596
            for line in files.iter_lines_added_or_present_in_keys(keys,
 
2597
                pb=progress):
 
2598
                lines.setdefault(line, 0)
 
2599
                lines[line] += 1
 
2600
            if []!= progress.updates:
 
2601
                self.assertEqual(expected, progress.updates)
 
2602
            return lines
 
2603
        lines = iter_with_keys(
 
2604
            [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)])
 
2608
        # we must see child and otherchild
 
2609
        self.assertTrue(lines[('child\n', self.get_simple_key('child'))] > 0)
 
2610
        self.assertTrue(
 
2611
            lines[('otherchild\n', self.get_simple_key('otherchild'))] > 0)
 
2612
        # we dont care if we got more than that.
 
2613
 
 
2614
        # test all lines
 
2615
        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)])
 
2622
        # all lines must be seen at least once
 
2623
        self.assertTrue(lines[('base\n', self.get_simple_key('base'))] > 0)
 
2624
        self.assertTrue(
 
2625
            lines[('lancestor\n', self.get_simple_key('lancestor'))] > 0)
 
2626
        self.assertTrue(
 
2627
            lines[('rancestor\n', self.get_simple_key('rancestor'))] > 0)
 
2628
        self.assertTrue(lines[('child\n', self.get_simple_key('child'))] > 0)
 
2629
        self.assertTrue(
 
2630
            lines[('otherchild\n', self.get_simple_key('otherchild'))] > 0)
 
2631
 
 
2632
    def test_make_mpdiffs(self):
 
2633
        from bzrlib import multiparent
 
2634
        files = self.get_versionedfiles('source')
 
2635
        # add texts that should trip the knit maximum delta chain threshold
 
2636
        # as well as doing parallel chains of data in knits.
 
2637
        # this is done by two chains of 25 insertions
 
2638
        files.add_lines(self.get_simple_key('base'), [], ['line\n'])
 
2639
        files.add_lines(self.get_simple_key('noeol'),
 
2640
            self.get_parents([self.get_simple_key('base')]), ['line'])
 
2641
        # detailed eol tests:
 
2642
        # shared last line with parent no-eol
 
2643
        files.add_lines(self.get_simple_key('noeolsecond'),
 
2644
            self.get_parents([self.get_simple_key('noeol')]),
 
2645
                ['line\n', 'line'])
 
2646
        # differing last line with parent, both no-eol
 
2647
        files.add_lines(self.get_simple_key('noeolnotshared'),
 
2648
            self.get_parents([self.get_simple_key('noeolsecond')]),
 
2649
                ['line\n', 'phone'])
 
2650
        # add eol following a noneol parent, change content
 
2651
        files.add_lines(self.get_simple_key('eol'),
 
2652
            self.get_parents([self.get_simple_key('noeol')]), ['phone\n'])
 
2653
        # add eol following a noneol parent, no change content
 
2654
        files.add_lines(self.get_simple_key('eolline'),
 
2655
            self.get_parents([self.get_simple_key('noeol')]), ['line\n'])
 
2656
        # noeol with no parents:
 
2657
        files.add_lines(self.get_simple_key('noeolbase'), [], ['line'])
 
2658
        # noeol preceeding its leftmost parent in the output:
 
2659
        # this is done by making it a merge of two parents with no common
 
2660
        # anestry: noeolbase and noeol with the
 
2661
        # later-inserted parent the leftmost.
 
2662
        files.add_lines(self.get_simple_key('eolbeforefirstparent'),
 
2663
            self.get_parents([self.get_simple_key('noeolbase'),
 
2664
                self.get_simple_key('noeol')]),
 
2665
            ['line'])
 
2666
        # two identical eol texts
 
2667
        files.add_lines(self.get_simple_key('noeoldup'),
 
2668
            self.get_parents([self.get_simple_key('noeol')]), ['line'])
 
2669
        next_parent = self.get_simple_key('base')
 
2670
        text_name = 'chain1-'
 
2671
        text = ['line\n']
 
2672
        sha1s = {0 :'da6d3141cb4a5e6f464bf6e0518042ddc7bfd079',
 
2673
                 1 :'45e21ea146a81ea44a821737acdb4f9791c8abe7',
 
2674
                 2 :'e1f11570edf3e2a070052366c582837a4fe4e9fa',
 
2675
                 3 :'26b4b8626da827088c514b8f9bbe4ebf181edda1',
 
2676
                 4 :'e28a5510be25ba84d31121cff00956f9970ae6f6',
 
2677
                 5 :'d63ec0ce22e11dcf65a931b69255d3ac747a318d',
 
2678
                 6 :'2c2888d288cb5e1d98009d822fedfe6019c6a4ea',
 
2679
                 7 :'95c14da9cafbf828e3e74a6f016d87926ba234ab',
 
2680
                 8 :'779e9a0b28f9f832528d4b21e17e168c67697272',
 
2681
                 9 :'1f8ff4e5c6ff78ac106fcfe6b1e8cb8740ff9a8f',
 
2682
                 10:'131a2ae712cf51ed62f143e3fbac3d4206c25a05',
 
2683
                 11:'c5a9d6f520d2515e1ec401a8f8a67e6c3c89f199',
 
2684
                 12:'31a2286267f24d8bedaa43355f8ad7129509ea85',
 
2685
                 13:'dc2a7fe80e8ec5cae920973973a8ee28b2da5e0a',
 
2686
                 14:'2c4b1736566b8ca6051e668de68650686a3922f2',
 
2687
                 15:'5912e4ecd9b0c07be4d013e7e2bdcf9323276cde',
 
2688
                 16:'b0d2e18d3559a00580f6b49804c23fea500feab3',
 
2689
                 17:'8e1d43ad72f7562d7cb8f57ee584e20eb1a69fc7',
 
2690
                 18:'5cf64a3459ae28efa60239e44b20312d25b253f3',
 
2691
                 19:'1ebed371807ba5935958ad0884595126e8c4e823',
 
2692
                 20:'2aa62a8b06fb3b3b892a3292a068ade69d5ee0d3',
 
2693
                 21:'01edc447978004f6e4e962b417a4ae1955b6fe5d',
 
2694
                 22:'d8d8dc49c4bf0bab401e0298bb5ad827768618bb',
 
2695
                 23:'c21f62b1c482862983a8ffb2b0c64b3451876e3f',
 
2696
                 24:'c0593fe795e00dff6b3c0fe857a074364d5f04fc',
 
2697
                 25:'dd1a1cf2ba9cc225c3aff729953e6364bf1d1855',
 
2698
                 }
 
2699
        for depth in range(26):
 
2700
            new_version = self.get_simple_key(text_name + '%s' % depth)
 
2701
            text = text + ['line\n']
 
2702
            files.add_lines(new_version, self.get_parents([next_parent]), text)
 
2703
            next_parent = new_version
 
2704
        next_parent = self.get_simple_key('base')
 
2705
        text_name = 'chain2-'
 
2706
        text = ['line\n']
 
2707
        for depth in range(26):
 
2708
            new_version = self.get_simple_key(text_name + '%s' % depth)
 
2709
            text = text + ['line\n']
 
2710
            files.add_lines(new_version, self.get_parents([next_parent]), text)
 
2711
            next_parent = new_version
 
2712
        target = self.get_versionedfiles('target')
 
2713
        for key in multiparent.topo_iter_keys(files, files.keys()):
 
2714
            mpdiff = files.make_mpdiffs([key])[0]
 
2715
            parents = files.get_parent_map([key])[key] or []
 
2716
            target.add_mpdiffs(
 
2717
                [(key, parents, files.get_sha1s([key])[key], mpdiff)])
 
2718
            self.assertEqualDiff(
 
2719
                files.get_record_stream([key], 'unordered',
 
2720
                    True).next().get_bytes_as('fulltext'),
 
2721
                target.get_record_stream([key], 'unordered',
 
2722
                    True).next().get_bytes_as('fulltext')
 
2723
                )
 
2724
 
 
2725
    def test_keys(self):
 
2726
        # While use is discouraged, versions() is still needed by aspects of
 
2727
        # bzr.
 
2728
        files = self.get_versionedfiles()
 
2729
        self.assertEqual(set(), set(files.keys()))
 
2730
        if self.key_length == 1:
 
2731
            key = ('foo',)
 
2732
        else:
 
2733
            key = ('foo', 'bar',)
 
2734
        files.add_lines(key, (), [])
 
2735
        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
        TestCase.setUp(self)
 
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.assertEquals({}, self.texts.get_sha1s([("NONEXISTENT",)]))
 
2772
 
 
2773
    def test_get_sha1s(self):
 
2774
        self._lines["key"] = ["dataline1", "dataline2"]
 
2775
        self.assertEquals({("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.assertEquals({("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.assertEquals("chunked", record.storage_kind)
 
2788
        self.assertEquals("FOOBAR", record.get_bytes_as("fulltext"))
 
2789
        self.assertEquals(["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.assertEquals("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.assertEquals(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)