~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_versionedfile.py

  • Committer: Vincent Ladeuil
  • Date: 2009-06-22 14:32:48 UTC
  • mto: (4471.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4472.
  • Revision ID: v.ladeuil+lp@free.fr-20090622143248-pe4av866hxgzn60e
Use the same method or function names for _dirstate_helpers in pyrex and
python modules.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005, 2009 Canonical Ltd
2
2
#
3
3
# Authors:
4
4
#   Johan Rydberg <jrydberg@gnu.org>
15
15
#
16
16
# You should have received a copy of the GNU General Public License
17
17
# along with this program; if not, write to the Free Software
18
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
19
 
20
20
 
21
21
# TODO: might be nice to create a versionedfile with some type of corruption
22
22
# considered typical and check that it can be detected/corrected.
23
23
 
 
24
from itertools import chain, izip
24
25
from StringIO import StringIO
25
26
 
26
 
import bzrlib
27
27
from bzrlib import (
28
28
    errors,
 
29
    groupcompress,
 
30
    knit as _mod_knit,
29
31
    osutils,
30
32
    progress,
31
33
    )
32
34
from bzrlib.errors import (
33
 
                           RevisionNotPresent, 
 
35
                           RevisionNotPresent,
34
36
                           RevisionAlreadyPresent,
35
37
                           WeaveParentMismatch
36
38
                           )
37
 
from bzrlib.knit import KnitVersionedFile, \
38
 
     KnitAnnotateFactory
39
 
from bzrlib.tests import TestCaseWithTransport
40
 
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
 
39
from bzrlib.knit import (
 
40
    cleanup_pack_knit,
 
41
    make_file_factory,
 
42
    make_pack_factory,
 
43
    KnitAnnotateFactory,
 
44
    KnitPlainFactory,
 
45
    )
 
46
from bzrlib.tests import (
 
47
    TestCase,
 
48
    TestCaseWithMemoryTransport,
 
49
    TestNotApplicable,
 
50
    TestSkipped,
 
51
    condition_isinstance,
 
52
    split_suite_by_condition,
 
53
    multiply_tests,
 
54
    )
 
55
from bzrlib.tests.http_utils import TestCaseWithWebserver
41
56
from bzrlib.trace import mutter
42
57
from bzrlib.transport import get_transport
43
58
from bzrlib.transport.memory import MemoryTransport
44
59
from bzrlib.tsort import topo_sort
 
60
from bzrlib.tuned_gzip import GzipFile
45
61
import bzrlib.versionedfile as versionedfile
 
62
from bzrlib.versionedfile import (
 
63
    ConstantMapper,
 
64
    HashEscapedPrefixMapper,
 
65
    PrefixMapper,
 
66
    VirtualVersionedFiles,
 
67
    make_versioned_files_factory,
 
68
    )
46
69
from bzrlib.weave import WeaveFile
47
70
from bzrlib.weavefile import read_weave, write_weave
48
71
 
49
72
 
 
73
def load_tests(standard_tests, module, loader):
 
74
    """Parameterize VersionedFiles tests for different implementations."""
 
75
    to_adapt, result = split_suite_by_condition(
 
76
        standard_tests, condition_isinstance(TestVersionedFiles))
 
77
    # We want to be sure of behaviour for:
 
78
    # weaves prefix layout (weave texts)
 
79
    # individually named weaves (weave inventories)
 
80
    # annotated knits - prefix|hash|hash-escape layout, we test the third only
 
81
    #                   as it is the most complex mapper.
 
82
    # individually named knits
 
83
    # individual no-graph knits in packs (signatures)
 
84
    # individual graph knits in packs (inventories)
 
85
    # individual graph nocompression knits in packs (revisions)
 
86
    # plain text knits in packs (texts)
 
87
    len_one_scenarios = [
 
88
        ('weave-named', {
 
89
            'cleanup':None,
 
90
            'factory':make_versioned_files_factory(WeaveFile,
 
91
                ConstantMapper('inventory')),
 
92
            'graph':True,
 
93
            'key_length':1,
 
94
            'support_partial_insertion': False,
 
95
            }),
 
96
        ('named-knit', {
 
97
            'cleanup':None,
 
98
            'factory':make_file_factory(False, ConstantMapper('revisions')),
 
99
            'graph':True,
 
100
            'key_length':1,
 
101
            'support_partial_insertion': False,
 
102
            }),
 
103
        ('named-nograph-nodelta-knit-pack', {
 
104
            'cleanup':cleanup_pack_knit,
 
105
            'factory':make_pack_factory(False, False, 1),
 
106
            'graph':False,
 
107
            'key_length':1,
 
108
            'support_partial_insertion': False,
 
109
            }),
 
110
        ('named-graph-knit-pack', {
 
111
            'cleanup':cleanup_pack_knit,
 
112
            'factory':make_pack_factory(True, True, 1),
 
113
            'graph':True,
 
114
            'key_length':1,
 
115
            'support_partial_insertion': True,
 
116
            }),
 
117
        ('named-graph-nodelta-knit-pack', {
 
118
            'cleanup':cleanup_pack_knit,
 
119
            'factory':make_pack_factory(True, False, 1),
 
120
            'graph':True,
 
121
            'key_length':1,
 
122
            'support_partial_insertion': False,
 
123
            }),
 
124
        ('groupcompress-nograph', {
 
125
            'cleanup':groupcompress.cleanup_pack_group,
 
126
            'factory':groupcompress.make_pack_factory(False, False, 1),
 
127
            'graph': False,
 
128
            'key_length':1,
 
129
            'support_partial_insertion':False,
 
130
            }),
 
131
        ]
 
132
    len_two_scenarios = [
 
133
        ('weave-prefix', {
 
134
            'cleanup':None,
 
135
            'factory':make_versioned_files_factory(WeaveFile,
 
136
                PrefixMapper()),
 
137
            'graph':True,
 
138
            'key_length':2,
 
139
            'support_partial_insertion': False,
 
140
            }),
 
141
        ('annotated-knit-escape', {
 
142
            'cleanup':None,
 
143
            'factory':make_file_factory(True, HashEscapedPrefixMapper()),
 
144
            'graph':True,
 
145
            'key_length':2,
 
146
            'support_partial_insertion': False,
 
147
            }),
 
148
        ('plain-knit-pack', {
 
149
            'cleanup':cleanup_pack_knit,
 
150
            'factory':make_pack_factory(True, True, 2),
 
151
            'graph':True,
 
152
            'key_length':2,
 
153
            'support_partial_insertion': True,
 
154
            }),
 
155
        ('groupcompress', {
 
156
            'cleanup':groupcompress.cleanup_pack_group,
 
157
            'factory':groupcompress.make_pack_factory(True, False, 1),
 
158
            'graph': True,
 
159
            'key_length':1,
 
160
            'support_partial_insertion':False,
 
161
            }),
 
162
        ]
 
163
    scenarios = len_one_scenarios + len_two_scenarios
 
164
    return multiply_tests(to_adapt, scenarios, result)
 
165
 
 
166
 
 
167
def get_diamond_vf(f, trailing_eol=True, left_only=False):
 
168
    """Get a diamond graph to exercise deltas and merges.
 
169
 
 
170
    :param trailing_eol: If True end the last line with \n.
 
171
    """
 
172
    parents = {
 
173
        'origin': (),
 
174
        'base': (('origin',),),
 
175
        'left': (('base',),),
 
176
        'right': (('base',),),
 
177
        'merged': (('left',), ('right',)),
 
178
        }
 
179
    # insert a diamond graph to exercise deltas and merges.
 
180
    if trailing_eol:
 
181
        last_char = '\n'
 
182
    else:
 
183
        last_char = ''
 
184
    f.add_lines('origin', [], ['origin' + last_char])
 
185
    f.add_lines('base', ['origin'], ['base' + last_char])
 
186
    f.add_lines('left', ['base'], ['base\n', 'left' + last_char])
 
187
    if not left_only:
 
188
        f.add_lines('right', ['base'],
 
189
            ['base\n', 'right' + last_char])
 
190
        f.add_lines('merged', ['left', 'right'],
 
191
            ['base\n', 'left\n', 'right\n', 'merged' + last_char])
 
192
    return f, parents
 
193
 
 
194
 
 
195
def get_diamond_files(files, key_length, trailing_eol=True, left_only=False,
 
196
    nograph=False, nokeys=False):
 
197
    """Get a diamond graph to exercise deltas and merges.
 
198
 
 
199
    This creates a 5-node graph in files. If files supports 2-length keys two
 
200
    graphs are made to exercise the support for multiple ids.
 
201
 
 
202
    :param trailing_eol: If True end the last line with \n.
 
203
    :param key_length: The length of keys in files. Currently supports length 1
 
204
        and 2 keys.
 
205
    :param left_only: If True do not add the right and merged nodes.
 
206
    :param nograph: If True, do not provide parents to the add_lines calls;
 
207
        this is useful for tests that need inserted data but have graphless
 
208
        stores.
 
209
    :param nokeys: If True, pass None is as the key for all insertions.
 
210
        Currently implies nograph.
 
211
    :return: The results of the add_lines calls.
 
212
    """
 
213
    if nokeys:
 
214
        nograph = True
 
215
    if key_length == 1:
 
216
        prefixes = [()]
 
217
    else:
 
218
        prefixes = [('FileA',), ('FileB',)]
 
219
    # insert a diamond graph to exercise deltas and merges.
 
220
    if trailing_eol:
 
221
        last_char = '\n'
 
222
    else:
 
223
        last_char = ''
 
224
    result = []
 
225
    def get_parents(suffix_list):
 
226
        if nograph:
 
227
            return ()
 
228
        else:
 
229
            result = [prefix + suffix for suffix in suffix_list]
 
230
            return result
 
231
    def get_key(suffix):
 
232
        if nokeys:
 
233
            return (None, )
 
234
        else:
 
235
            return (suffix,)
 
236
    # we loop over each key because that spreads the inserts across prefixes,
 
237
    # which is how commit operates.
 
238
    for prefix in prefixes:
 
239
        result.append(files.add_lines(prefix + get_key('origin'), (),
 
240
            ['origin' + last_char]))
 
241
    for prefix in prefixes:
 
242
        result.append(files.add_lines(prefix + get_key('base'),
 
243
            get_parents([('origin',)]), ['base' + last_char]))
 
244
    for prefix in prefixes:
 
245
        result.append(files.add_lines(prefix + get_key('left'),
 
246
            get_parents([('base',)]),
 
247
            ['base\n', 'left' + last_char]))
 
248
    if not left_only:
 
249
        for prefix in prefixes:
 
250
            result.append(files.add_lines(prefix + get_key('right'),
 
251
                get_parents([('base',)]),
 
252
                ['base\n', 'right' + last_char]))
 
253
        for prefix in prefixes:
 
254
            result.append(files.add_lines(prefix + get_key('merged'),
 
255
                get_parents([('left',), ('right',)]),
 
256
                ['base\n', 'left\n', 'right\n', 'merged' + last_char]))
 
257
    return result
 
258
 
 
259
 
50
260
class VersionedFileTestMixIn(object):
51
261
    """A mixin test class for testing VersionedFiles.
52
262
 
55
265
    they are strictly controlled by their owning repositories.
56
266
    """
57
267
 
 
268
    def get_transaction(self):
 
269
        if not hasattr(self, '_transaction'):
 
270
            self._transaction = None
 
271
        return self._transaction
 
272
 
58
273
    def test_add(self):
59
274
        f = self.get_file()
60
275
        f.add_lines('r0', [], ['a\n', 'b\n'])
68
283
            self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
69
284
            self.assertEqual(2, len(f))
70
285
            self.assertEqual(2, f.num_versions())
71
 
    
 
286
 
72
287
            self.assertRaises(RevisionNotPresent,
73
288
                f.add_lines, 'r2', ['foo'], [])
74
289
            self.assertRaises(RevisionAlreadyPresent,
81
296
    def test_adds_with_parent_texts(self):
82
297
        f = self.get_file()
83
298
        parent_texts = {}
84
 
        parent_texts['r0'] = f.add_lines('r0', [], ['a\n', 'b\n'])
 
299
        _, _, parent_texts['r0'] = f.add_lines('r0', [], ['a\n', 'b\n'])
85
300
        try:
86
 
            parent_texts['r1'] = f.add_lines_with_ghosts('r1',
87
 
                                                         ['r0', 'ghost'], 
88
 
                                                         ['b\n', 'c\n'],
89
 
                                                         parent_texts=parent_texts)
 
301
            _, _, parent_texts['r1'] = f.add_lines_with_ghosts('r1',
 
302
                ['r0', 'ghost'], ['b\n', 'c\n'], parent_texts=parent_texts)
90
303
        except NotImplementedError:
91
304
            # if the format doesn't support ghosts, just add normally.
92
 
            parent_texts['r1'] = f.add_lines('r1',
93
 
                                             ['r0'], 
94
 
                                             ['b\n', 'c\n'],
95
 
                                             parent_texts=parent_texts)
 
305
            _, _, parent_texts['r1'] = f.add_lines('r1',
 
306
                ['r0'], ['b\n', 'c\n'], parent_texts=parent_texts)
96
307
        f.add_lines('r2', ['r1'], ['c\n', 'd\n'], parent_texts=parent_texts)
97
308
        self.assertNotEqual(None, parent_texts['r0'])
98
309
        self.assertNotEqual(None, parent_texts['r1'])
117
328
        verify_file(f)
118
329
 
119
330
    def test_add_unicode_content(self):
120
 
        # unicode content is not permitted in versioned files. 
 
331
        # unicode content is not permitted in versioned files.
121
332
        # versioned files version sequences of bytes only.
122
333
        vf = self.get_file()
123
334
        self.assertRaises(errors.BzrBadParameterUnicode,
126
337
            (errors.BzrBadParameterUnicode, NotImplementedError),
127
338
            vf.add_lines_with_ghosts, 'a', [], ['a\n', u'b\n', 'c\n'])
128
339
 
 
340
    def test_add_follows_left_matching_blocks(self):
 
341
        """If we change left_matching_blocks, delta changes
 
342
 
 
343
        Note: There are multiple correct deltas in this case, because
 
344
        we start with 1 "a" and we get 3.
 
345
        """
 
346
        vf = self.get_file()
 
347
        if isinstance(vf, WeaveFile):
 
348
            raise TestSkipped("WeaveFile ignores left_matching_blocks")
 
349
        vf.add_lines('1', [], ['a\n'])
 
350
        vf.add_lines('2', ['1'], ['a\n', 'a\n', 'a\n'],
 
351
                     left_matching_blocks=[(0, 0, 1), (1, 3, 0)])
 
352
        self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('2'))
 
353
        vf.add_lines('3', ['1'], ['a\n', 'a\n', 'a\n'],
 
354
                     left_matching_blocks=[(0, 2, 1), (1, 3, 0)])
 
355
        self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('3'))
 
356
 
129
357
    def test_inline_newline_throws(self):
130
358
        # \r characters are not permitted in lines being added
131
359
        vf = self.get_file()
132
 
        self.assertRaises(errors.BzrBadParameterContainsNewline, 
 
360
        self.assertRaises(errors.BzrBadParameterContainsNewline,
133
361
            vf.add_lines, 'a', [], ['a\n\n'])
134
362
        self.assertRaises(
135
363
            (errors.BzrBadParameterContainsNewline, NotImplementedError),
146
374
        self.assertRaises(errors.ReservedId,
147
375
            vf.add_lines, 'a:', [], ['a\n', 'b\n', 'c\n'])
148
376
 
149
 
        self.assertRaises(errors.ReservedId,
150
 
            vf.add_delta, 'a:', [], None, 'sha1', False, ((0, 0, 0, []),))
 
377
    def test_add_lines_nostoresha(self):
 
378
        """When nostore_sha is supplied using old content raises."""
 
379
        vf = self.get_file()
 
380
        empty_text = ('a', [])
 
381
        sample_text_nl = ('b', ["foo\n", "bar\n"])
 
382
        sample_text_no_nl = ('c', ["foo\n", "bar"])
 
383
        shas = []
 
384
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
 
385
            sha, _, _ = vf.add_lines(version, [], lines)
 
386
            shas.append(sha)
 
387
        # we now have a copy of all the lines in the vf.
 
388
        for sha, (version, lines) in zip(
 
389
            shas, (empty_text, sample_text_nl, sample_text_no_nl)):
 
390
            self.assertRaises(errors.ExistingContent,
 
391
                vf.add_lines, version + "2", [], lines,
 
392
                nostore_sha=sha)
 
393
            # and no new version should have been added.
 
394
            self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
 
395
                version + "2")
 
396
 
 
397
    def test_add_lines_with_ghosts_nostoresha(self):
 
398
        """When nostore_sha is supplied using old content raises."""
 
399
        vf = self.get_file()
 
400
        empty_text = ('a', [])
 
401
        sample_text_nl = ('b', ["foo\n", "bar\n"])
 
402
        sample_text_no_nl = ('c', ["foo\n", "bar"])
 
403
        shas = []
 
404
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
 
405
            sha, _, _ = vf.add_lines(version, [], lines)
 
406
            shas.append(sha)
 
407
        # we now have a copy of all the lines in the vf.
 
408
        # is the test applicable to this vf implementation?
 
409
        try:
 
410
            vf.add_lines_with_ghosts('d', [], [])
 
411
        except NotImplementedError:
 
412
            raise TestSkipped("add_lines_with_ghosts is optional")
 
413
        for sha, (version, lines) in zip(
 
414
            shas, (empty_text, sample_text_nl, sample_text_no_nl)):
 
415
            self.assertRaises(errors.ExistingContent,
 
416
                vf.add_lines_with_ghosts, version + "2", [], lines,
 
417
                nostore_sha=sha)
 
418
            # and no new version should have been added.
 
419
            self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
 
420
                version + "2")
 
421
 
 
422
    def test_add_lines_return_value(self):
 
423
        # add_lines should return the sha1 and the text size.
 
424
        vf = self.get_file()
 
425
        empty_text = ('a', [])
 
426
        sample_text_nl = ('b', ["foo\n", "bar\n"])
 
427
        sample_text_no_nl = ('c', ["foo\n", "bar"])
 
428
        # check results for the three cases:
 
429
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
 
430
            # the first two elements are the same for all versioned files:
 
431
            # - the digest and the size of the text. For some versioned files
 
432
            #   additional data is returned in additional tuple elements.
 
433
            result = vf.add_lines(version, [], lines)
 
434
            self.assertEqual(3, len(result))
 
435
            self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
 
436
                result[0:2])
 
437
        # parents should not affect the result:
 
438
        lines = sample_text_nl[1]
 
439
        self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
 
440
            vf.add_lines('d', ['b', 'c'], lines)[0:2])
151
441
 
152
442
    def test_get_reserved(self):
153
443
        vf = self.get_file()
154
 
        self.assertRaises(errors.ReservedId, vf.get_delta, 'b:')
155
444
        self.assertRaises(errors.ReservedId, vf.get_texts, ['b:'])
156
445
        self.assertRaises(errors.ReservedId, vf.get_lines, 'b:')
157
446
        self.assertRaises(errors.ReservedId, vf.get_text, 'b:')
158
447
 
159
 
    def test_get_delta(self):
160
 
        f = self.get_file()
161
 
        sha1s = self._setup_for_deltas(f)
162
 
        expected_delta = (None, '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
163
 
                          [(0, 0, 1, [('base', 'line\n')])])
164
 
        self.assertEqual(expected_delta, f.get_delta('base'))
165
 
        next_parent = 'base'
166
 
        text_name = 'chain1-'
167
 
        for depth in range(26):
168
 
            new_version = text_name + '%s' % depth
169
 
            expected_delta = (next_parent, sha1s[depth], 
170
 
                              False,
171
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
172
 
            self.assertEqual(expected_delta, f.get_delta(new_version))
173
 
            next_parent = new_version
174
 
        next_parent = 'base'
175
 
        text_name = 'chain2-'
176
 
        for depth in range(26):
177
 
            new_version = text_name + '%s' % depth
178
 
            expected_delta = (next_parent, sha1s[depth], False,
179
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
180
 
            self.assertEqual(expected_delta, f.get_delta(new_version))
181
 
            next_parent = new_version
182
 
        # smoke test for eol support
183
 
        expected_delta = ('base', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, [])
184
 
        self.assertEqual(['line'], f.get_lines('noeol'))
185
 
        self.assertEqual(expected_delta, f.get_delta('noeol'))
186
 
 
187
 
    def test_get_deltas(self):
188
 
        f = self.get_file()
189
 
        sha1s = self._setup_for_deltas(f)
190
 
        deltas = f.get_deltas(f.versions())
191
 
        expected_delta = (None, '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
192
 
                          [(0, 0, 1, [('base', 'line\n')])])
193
 
        self.assertEqual(expected_delta, deltas['base'])
194
 
        next_parent = 'base'
195
 
        text_name = 'chain1-'
196
 
        for depth in range(26):
197
 
            new_version = text_name + '%s' % depth
198
 
            expected_delta = (next_parent, sha1s[depth], 
199
 
                              False,
200
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
201
 
            self.assertEqual(expected_delta, deltas[new_version])
202
 
            next_parent = new_version
203
 
        next_parent = 'base'
204
 
        text_name = 'chain2-'
205
 
        for depth in range(26):
206
 
            new_version = text_name + '%s' % depth
207
 
            expected_delta = (next_parent, sha1s[depth], False,
208
 
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
209
 
            self.assertEqual(expected_delta, deltas[new_version])
210
 
            next_parent = new_version
211
 
        # smoke tests for eol support
212
 
        expected_delta = ('base', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, [])
213
 
        self.assertEqual(['line'], f.get_lines('noeol'))
214
 
        self.assertEqual(expected_delta, deltas['noeol'])
215
 
        # smoke tests for eol support - two noeol in a row same content
216
 
        expected_deltas = (('noeol', '3ad7ee82dbd8f29ecba073f96e43e414b3f70a4d', True, 
217
 
                          [(0, 1, 2, [('noeolsecond', 'line\n'), ('noeolsecond', 'line\n')])]),
218
 
                          ('noeol', '3ad7ee82dbd8f29ecba073f96e43e414b3f70a4d', True, 
219
 
                           [(0, 0, 1, [('noeolsecond', 'line\n')]), (1, 1, 0, [])]))
220
 
        self.assertEqual(['line\n', 'line'], f.get_lines('noeolsecond'))
221
 
        self.assertTrue(deltas['noeolsecond'] in expected_deltas)
222
 
        # two no-eol in a row, different content
223
 
        expected_delta = ('noeolsecond', '8bb553a84e019ef1149db082d65f3133b195223b', True, 
224
 
                          [(1, 2, 1, [('noeolnotshared', 'phone\n')])])
225
 
        self.assertEqual(['line\n', 'phone'], f.get_lines('noeolnotshared'))
226
 
        self.assertEqual(expected_delta, deltas['noeolnotshared'])
227
 
        # eol folling a no-eol with content change
228
 
        expected_delta = ('noeol', 'a61f6fb6cfc4596e8d88c34a308d1e724caf8977', False, 
229
 
                          [(0, 1, 1, [('eol', 'phone\n')])])
230
 
        self.assertEqual(['phone\n'], f.get_lines('eol'))
231
 
        self.assertEqual(expected_delta, deltas['eol'])
232
 
        # eol folling a no-eol with content change
233
 
        expected_delta = ('noeol', '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
234
 
                          [(0, 1, 1, [('eolline', 'line\n')])])
235
 
        self.assertEqual(['line\n'], f.get_lines('eolline'))
236
 
        self.assertEqual(expected_delta, deltas['eolline'])
237
 
        # eol with no parents
238
 
        expected_delta = (None, '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, 
239
 
                          [(0, 0, 1, [('noeolbase', 'line\n')])])
240
 
        self.assertEqual(['line'], f.get_lines('noeolbase'))
241
 
        self.assertEqual(expected_delta, deltas['noeolbase'])
242
 
        # eol with two parents, in inverse insertion order
243
 
        expected_deltas = (('noeolbase', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True,
244
 
                            [(0, 1, 1, [('eolbeforefirstparent', 'line\n')])]),
245
 
                           ('noeolbase', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True,
246
 
                            [(0, 1, 1, [('eolbeforefirstparent', 'line\n')])]))
247
 
        self.assertEqual(['line'], f.get_lines('eolbeforefirstparent'))
248
 
        #self.assertTrue(deltas['eolbeforefirstparent'] in expected_deltas)
 
448
    def test_add_unchanged_last_line_noeol_snapshot(self):
 
449
        """Add a text with an unchanged last line with no eol should work."""
 
450
        # Test adding this in a number of chain lengths; because the interface
 
451
        # for VersionedFile does not allow forcing a specific chain length, we
 
452
        # just use a small base to get the first snapshot, then a much longer
 
453
        # first line for the next add (which will make the third add snapshot)
 
454
        # and so on. 20 has been chosen as an aribtrary figure - knits use 200
 
455
        # as a capped delta length, but ideally we would have some way of
 
456
        # tuning the test to the store (e.g. keep going until a snapshot
 
457
        # happens).
 
458
        for length in range(20):
 
459
            version_lines = {}
 
460
            vf = self.get_file('case-%d' % length)
 
461
            prefix = 'step-%d'
 
462
            parents = []
 
463
            for step in range(length):
 
464
                version = prefix % step
 
465
                lines = (['prelude \n'] * step) + ['line']
 
466
                vf.add_lines(version, parents, lines)
 
467
                version_lines[version] = lines
 
468
                parents = [version]
 
469
            vf.add_lines('no-eol', parents, ['line'])
 
470
            vf.get_texts(version_lines.keys())
 
471
            self.assertEqualDiff('line', vf.get_text('no-eol'))
 
472
 
 
473
    def test_get_texts_eol_variation(self):
 
474
        # similar to the failure in <http://bugs.launchpad.net/234748>
 
475
        vf = self.get_file()
 
476
        sample_text_nl = ["line\n"]
 
477
        sample_text_no_nl = ["line"]
 
478
        versions = []
 
479
        version_lines = {}
 
480
        parents = []
 
481
        for i in range(4):
 
482
            version = 'v%d' % i
 
483
            if i % 2:
 
484
                lines = sample_text_nl
 
485
            else:
 
486
                lines = sample_text_no_nl
 
487
            # left_matching blocks is an internal api; it operates on the
 
488
            # *internal* representation for a knit, which is with *all* lines
 
489
            # being normalised to end with \n - even the final line in a no_nl
 
490
            # file. Using it here ensures that a broken internal implementation
 
491
            # (which is what this test tests) will generate a correct line
 
492
            # delta (which is to say, an empty delta).
 
493
            vf.add_lines(version, parents, lines,
 
494
                left_matching_blocks=[(0, 0, 1)])
 
495
            parents = [version]
 
496
            versions.append(version)
 
497
            version_lines[version] = lines
 
498
        vf.check()
 
499
        vf.get_texts(versions)
 
500
        vf.get_texts(reversed(versions))
 
501
 
 
502
    def test_add_lines_with_matching_blocks_noeol_last_line(self):
 
503
        """Add a text with an unchanged last line with no eol should work."""
 
504
        from bzrlib import multiparent
 
505
        # Hand verified sha1 of the text we're adding.
 
506
        sha1 = '6a1d115ec7b60afb664dc14890b5af5ce3c827a4'
 
507
        # Create a mpdiff which adds a new line before the trailing line, and
 
508
        # reuse the last line unaltered (which can cause annotation reuse).
 
509
        # Test adding this in two situations:
 
510
        # On top of a new insertion
 
511
        vf = self.get_file('fulltext')
 
512
        vf.add_lines('noeol', [], ['line'])
 
513
        vf.add_lines('noeol2', ['noeol'], ['newline\n', 'line'],
 
514
            left_matching_blocks=[(0, 1, 1)])
 
515
        self.assertEqualDiff('newline\nline', vf.get_text('noeol2'))
 
516
        # On top of a delta
 
517
        vf = self.get_file('delta')
 
518
        vf.add_lines('base', [], ['line'])
 
519
        vf.add_lines('noeol', ['base'], ['prelude\n', 'line'])
 
520
        vf.add_lines('noeol2', ['noeol'], ['newline\n', 'line'],
 
521
            left_matching_blocks=[(1, 1, 1)])
 
522
        self.assertEqualDiff('newline\nline', vf.get_text('noeol2'))
 
523
 
 
524
    def test_make_mpdiffs(self):
 
525
        from bzrlib import multiparent
 
526
        vf = self.get_file('foo')
 
527
        sha1s = self._setup_for_deltas(vf)
 
528
        new_vf = self.get_file('bar')
 
529
        for version in multiparent.topo_iter(vf):
 
530
            mpdiff = vf.make_mpdiffs([version])[0]
 
531
            new_vf.add_mpdiffs([(version, vf.get_parent_map([version])[version],
 
532
                                 vf.get_sha1s([version])[version], mpdiff)])
 
533
            self.assertEqualDiff(vf.get_text(version),
 
534
                                 new_vf.get_text(version))
 
535
 
 
536
    def test_make_mpdiffs_with_ghosts(self):
 
537
        vf = self.get_file('foo')
 
538
        try:
 
539
            vf.add_lines_with_ghosts('text', ['ghost'], ['line\n'])
 
540
        except NotImplementedError:
 
541
            # old Weave formats do not allow ghosts
 
542
            return
 
543
        self.assertRaises(errors.RevisionNotPresent, vf.make_mpdiffs, ['ghost'])
249
544
 
250
545
    def _setup_for_deltas(self, f):
251
 
        self.assertRaises(errors.RevisionNotPresent, f.get_delta, 'base')
 
546
        self.assertFalse(f.has_version('base'))
252
547
        # add texts that should trip the knit maximum delta chain threshold
253
548
        # as well as doing parallel chains of data in knits.
254
549
        # this is done by two chains of 25 insertions
267
562
        f.add_lines('noeolbase', [], ['line'])
268
563
        # noeol preceeding its leftmost parent in the output:
269
564
        # this is done by making it a merge of two parents with no common
270
 
        # anestry: noeolbase and noeol with the 
 
565
        # anestry: noeolbase and noeol with the
271
566
        # later-inserted parent the leftmost.
272
567
        f.add_lines('eolbeforefirstparent', ['noeolbase', 'noeol'], ['line'])
273
568
        # two identical eol texts
317
612
            next_parent = new_version
318
613
        return sha1s
319
614
 
320
 
    def test_add_delta(self):
321
 
        # tests for the add-delta facility.
322
 
        # at this point, optimising for speed, we assume no checks when deltas are inserted.
323
 
        # this may need to be revisited.
324
 
        source = self.get_file('source')
325
 
        source.add_lines('base', [], ['line\n'])
326
 
        next_parent = 'base'
327
 
        text_name = 'chain1-'
328
 
        text = ['line\n']
329
 
        for depth in range(26):
330
 
            new_version = text_name + '%s' % depth
331
 
            text = text + ['line\n']
332
 
            source.add_lines(new_version, [next_parent], text)
333
 
            next_parent = new_version
334
 
        next_parent = 'base'
335
 
        text_name = 'chain2-'
336
 
        text = ['line\n']
337
 
        for depth in range(26):
338
 
            new_version = text_name + '%s' % depth
339
 
            text = text + ['line\n']
340
 
            source.add_lines(new_version, [next_parent], text)
341
 
            next_parent = new_version
342
 
        source.add_lines('noeol', ['base'], ['line'])
343
 
        
344
 
        target = self.get_file('target')
345
 
        for version in source.versions():
346
 
            parent, sha1, noeol, delta = source.get_delta(version)
347
 
            target.add_delta(version,
348
 
                             source.get_parents(version),
349
 
                             parent,
350
 
                             sha1,
351
 
                             noeol,
352
 
                             delta)
353
 
        self.assertRaises(RevisionAlreadyPresent,
354
 
                          target.add_delta, 'base', [], None, '', False, [])
355
 
        for version in source.versions():
356
 
            self.assertEqual(source.get_lines(version),
357
 
                             target.get_lines(version))
358
 
 
359
615
    def test_ancestry(self):
360
616
        f = self.get_file()
361
617
        self.assertEqual([], f.get_ancestry([]))
384
640
        self.assertRaises(RevisionNotPresent,
385
641
            f.get_ancestry, ['rM', 'rX'])
386
642
 
 
643
        self.assertEqual(set(f.get_ancestry('rM')),
 
644
            set(f.get_ancestry('rM', topo_sorted=False)))
 
645
 
387
646
    def test_mutate_after_finish(self):
 
647
        self._transaction = 'before'
388
648
        f = self.get_file()
389
 
        f.transaction_finished()
390
 
        self.assertRaises(errors.OutSideTransaction, f.add_delta, '', [], '', '', False, [])
 
649
        self._transaction = 'after'
391
650
        self.assertRaises(errors.OutSideTransaction, f.add_lines, '', [], [])
392
651
        self.assertRaises(errors.OutSideTransaction, f.add_lines_with_ghosts, '', [], [])
393
 
        self.assertRaises(errors.OutSideTransaction, f.fix_parents, '', [])
394
 
        self.assertRaises(errors.OutSideTransaction, f.join, '')
395
 
        self.assertRaises(errors.OutSideTransaction, f.clone_text, 'base', 'bar', ['foo'])
396
 
        
397
 
    def test_clear_cache(self):
398
 
        f = self.get_file()
399
 
        # on a new file it should not error
400
 
        f.clear_cache()
401
 
        # and after adding content, doing a clear_cache and a get should work.
402
 
        f.add_lines('0', [], ['a'])
403
 
        f.clear_cache()
404
 
        self.assertEqual(['a'], f.get_lines('0'))
405
 
 
406
 
    def test_clone_text(self):
407
 
        f = self.get_file()
408
 
        f.add_lines('r0', [], ['a\n', 'b\n'])
409
 
        f.clone_text('r1', 'r0', ['r0'])
410
 
        def verify_file(f):
411
 
            self.assertEquals(f.get_lines('r1'), f.get_lines('r0'))
412
 
            self.assertEquals(f.get_lines('r1'), ['a\n', 'b\n'])
413
 
            self.assertEquals(f.get_parents('r1'), ['r0'])
414
 
    
415
 
            self.assertRaises(RevisionNotPresent,
416
 
                f.clone_text, 'r2', 'rX', [])
417
 
            self.assertRaises(RevisionAlreadyPresent,
418
 
                f.clone_text, 'r1', 'r0', [])
419
 
        verify_file(f)
420
 
        verify_file(self.reopen_file())
421
 
 
422
 
    def test_create_empty(self):
423
 
        f = self.get_file()
424
 
        f.add_lines('0', [], ['a\n'])
425
 
        new_f = f.create_empty('t', MemoryTransport())
426
 
        # smoke test, specific types should check it is honoured correctly for
427
 
        # non type attributes
428
 
        self.assertEqual([], new_f.versions())
429
 
        self.assertTrue(isinstance(new_f, f.__class__))
430
652
 
431
653
    def test_copy_to(self):
432
654
        f = self.get_file()
433
655
        f.add_lines('0', [], ['a\n'])
434
656
        t = MemoryTransport()
435
657
        f.copy_to('foo', t)
436
 
        for suffix in f.__class__.get_suffixes():
 
658
        for suffix in self.get_factory().get_suffixes():
437
659
            self.assertTrue(t.has('foo' + suffix))
438
660
 
439
661
    def test_get_suffixes(self):
440
662
        f = self.get_file()
441
 
        # should be the same
442
 
        self.assertEqual(f.__class__.get_suffixes(), f.__class__.get_suffixes())
443
663
        # and should be a list
444
 
        self.assertTrue(isinstance(f.__class__.get_suffixes(), list))
445
 
 
446
 
    def build_graph(self, file, graph):
447
 
        for node in topo_sort(graph.items()):
448
 
            file.add_lines(node, graph[node], [])
449
 
 
450
 
    def test_get_graph(self):
451
 
        f = self.get_file()
452
 
        graph = {
453
 
            'v1': [],
454
 
            'v2': ['v1'],
455
 
            'v3': ['v2']}
456
 
        self.build_graph(f, graph)
457
 
        self.assertEqual(graph, f.get_graph())
458
 
    
459
 
    def test_get_graph_partial(self):
460
 
        f = self.get_file()
461
 
        complex_graph = {}
462
 
        simple_a = {
463
 
            'c': [],
464
 
            'b': ['c'],
465
 
            'a': ['b'],
466
 
            }
467
 
        complex_graph.update(simple_a)
468
 
        simple_b = {
469
 
            'c': [],
470
 
            'b': ['c'],
471
 
            }
472
 
        complex_graph.update(simple_b)
473
 
        simple_gam = {
474
 
            'c': [],
475
 
            'oo': [],
476
 
            'bar': ['oo', 'c'],
477
 
            'gam': ['bar'],
478
 
            }
479
 
        complex_graph.update(simple_gam)
480
 
        simple_b_gam = {}
481
 
        simple_b_gam.update(simple_gam)
482
 
        simple_b_gam.update(simple_b)
483
 
        self.build_graph(f, complex_graph)
484
 
        self.assertEqual(simple_a, f.get_graph(['a']))
485
 
        self.assertEqual(simple_b, f.get_graph(['b']))
486
 
        self.assertEqual(simple_gam, f.get_graph(['gam']))
487
 
        self.assertEqual(simple_b_gam, f.get_graph(['b', 'gam']))
488
 
 
489
 
    def test_get_parents(self):
 
664
        self.assertTrue(isinstance(self.get_factory().get_suffixes(), list))
 
665
 
 
666
    def test_get_parent_map(self):
490
667
        f = self.get_file()
491
668
        f.add_lines('r0', [], ['a\n', 'b\n'])
492
 
        f.add_lines('r1', [], ['a\n', 'b\n'])
 
669
        self.assertEqual(
 
670
            {'r0':()}, f.get_parent_map(['r0']))
 
671
        f.add_lines('r1', ['r0'], ['a\n', 'b\n'])
 
672
        self.assertEqual(
 
673
            {'r1':('r0',)}, f.get_parent_map(['r1']))
 
674
        self.assertEqual(
 
675
            {'r0':(),
 
676
             'r1':('r0',)},
 
677
            f.get_parent_map(['r0', 'r1']))
493
678
        f.add_lines('r2', [], ['a\n', 'b\n'])
494
679
        f.add_lines('r3', [], ['a\n', 'b\n'])
495
680
        f.add_lines('m', ['r0', 'r1', 'r2', 'r3'], ['a\n', 'b\n'])
496
 
        self.assertEquals(f.get_parents('m'), ['r0', 'r1', 'r2', 'r3'])
497
 
 
498
 
        self.assertRaises(RevisionNotPresent,
499
 
            f.get_parents, 'y')
 
681
        self.assertEqual(
 
682
            {'m':('r0', 'r1', 'r2', 'r3')}, f.get_parent_map(['m']))
 
683
        self.assertEqual({}, f.get_parent_map('y'))
 
684
        self.assertEqual(
 
685
            {'r0':(),
 
686
             'r1':('r0',)},
 
687
            f.get_parent_map(['r0', 'y', 'r1']))
500
688
 
501
689
    def test_annotate(self):
502
690
        f = self.get_file()
509
697
        self.assertRaises(RevisionNotPresent,
510
698
            f.annotate, 'foo')
511
699
 
512
 
    def test_walk(self):
513
 
        # tests that walk returns all the inclusions for the requested
514
 
        # revisions as well as the revisions changes themselves.
515
 
        f = self.get_file('1')
516
 
        f.add_lines('r0', [], ['a\n', 'b\n'])
517
 
        f.add_lines('r1', ['r0'], ['c\n', 'b\n'])
518
 
        f.add_lines('rX', ['r1'], ['d\n', 'b\n'])
519
 
        f.add_lines('rY', ['r1'], ['c\n', 'e\n'])
520
 
 
521
 
        lines = {}
522
 
        for lineno, insert, dset, text in f.walk(['rX', 'rY']):
523
 
            lines[text] = (insert, dset)
524
 
 
525
 
        self.assertTrue(lines['a\n'], ('r0', set(['r1'])))
526
 
        self.assertTrue(lines['b\n'], ('r0', set(['rY'])))
527
 
        self.assertTrue(lines['c\n'], ('r1', set(['rX'])))
528
 
        self.assertTrue(lines['d\n'], ('rX', set([])))
529
 
        self.assertTrue(lines['e\n'], ('rY', set([])))
530
 
 
531
700
    def test_detection(self):
532
701
        # Test weaves detect corruption.
533
702
        #
559
728
 
560
729
    def test_iter_lines_added_or_present_in_versions(self):
561
730
        # test that we get at least an equalset of the lines added by
562
 
        # versions in the weave 
 
731
        # versions in the weave
563
732
        # the ordering here is to make a tree so that dumb searches have
564
733
        # more changes to muck up.
565
734
 
588
757
                     ['base\n', 'lancestor\n', 'otherchild\n'])
589
758
        def iter_with_versions(versions, expected):
590
759
            # now we need to see what lines are returned, and how often.
591
 
            lines = {'base\n':0,
592
 
                     'lancestor\n':0,
593
 
                     'rancestor\n':0,
594
 
                     'child\n':0,
595
 
                     'otherchild\n':0,
596
 
                     }
 
760
            lines = {}
597
761
            progress = InstrumentedProgress()
598
762
            # iterate over the lines
599
 
            for line in vf.iter_lines_added_or_present_in_versions(versions, 
 
763
            for line in vf.iter_lines_added_or_present_in_versions(versions,
600
764
                pb=progress):
 
765
                lines.setdefault(line, 0)
601
766
                lines[line] += 1
602
 
            if []!= progress.updates: 
 
767
            if []!= progress.updates:
603
768
                self.assertEqual(expected, progress.updates)
604
769
            return lines
605
770
        lines = iter_with_versions(['child', 'otherchild'],
606
 
                                   [('Walking content.', 0, 2),
607
 
                                    ('Walking content.', 1, 2),
608
 
                                    ('Walking content.', 2, 2)])
 
771
                                   [('Walking content', 0, 2),
 
772
                                    ('Walking content', 1, 2),
 
773
                                    ('Walking content', 2, 2)])
609
774
        # we must see child and otherchild
610
 
        self.assertTrue(lines['child\n'] > 0)
611
 
        self.assertTrue(lines['otherchild\n'] > 0)
 
775
        self.assertTrue(lines[('child\n', 'child')] > 0)
 
776
        self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
612
777
        # we dont care if we got more than that.
613
 
        
 
778
 
614
779
        # test all lines
615
 
        lines = iter_with_versions(None, [('Walking content.', 0, 5),
616
 
                                          ('Walking content.', 1, 5),
617
 
                                          ('Walking content.', 2, 5),
618
 
                                          ('Walking content.', 3, 5),
619
 
                                          ('Walking content.', 4, 5),
620
 
                                          ('Walking content.', 5, 5)])
 
780
        lines = iter_with_versions(None, [('Walking content', 0, 5),
 
781
                                          ('Walking content', 1, 5),
 
782
                                          ('Walking content', 2, 5),
 
783
                                          ('Walking content', 3, 5),
 
784
                                          ('Walking content', 4, 5),
 
785
                                          ('Walking content', 5, 5)])
621
786
        # all lines must be seen at least once
622
 
        self.assertTrue(lines['base\n'] > 0)
623
 
        self.assertTrue(lines['lancestor\n'] > 0)
624
 
        self.assertTrue(lines['rancestor\n'] > 0)
625
 
        self.assertTrue(lines['child\n'] > 0)
626
 
        self.assertTrue(lines['otherchild\n'] > 0)
627
 
 
628
 
    def test_fix_parents(self):
629
 
        # some versioned files allow incorrect parents to be corrected after
630
 
        # insertion - this may not fix ancestry..
631
 
        # if they do not supported, they just do not implement it.
632
 
        # we test this as an interface test to ensure that those that *do*
633
 
        # implementent it get it right.
634
 
        vf = self.get_file()
635
 
        vf.add_lines('notbase', [], [])
636
 
        vf.add_lines('base', [], [])
637
 
        try:
638
 
            vf.fix_parents('notbase', ['base'])
639
 
        except NotImplementedError:
640
 
            return
641
 
        self.assertEqual(['base'], vf.get_parents('notbase'))
642
 
        # open again, check it stuck.
643
 
        vf = self.get_file()
644
 
        self.assertEqual(['base'], vf.get_parents('notbase'))
645
 
 
646
 
    def test_fix_parents_with_ghosts(self):
647
 
        # when fixing parents, ghosts that are listed should not be ghosts
648
 
        # anymore.
649
 
        vf = self.get_file()
650
 
 
651
 
        try:
652
 
            vf.add_lines_with_ghosts('notbase', ['base', 'stillghost'], [])
653
 
        except NotImplementedError:
654
 
            return
655
 
        vf.add_lines('base', [], [])
656
 
        vf.fix_parents('notbase', ['base', 'stillghost'])
657
 
        self.assertEqual(['base'], vf.get_parents('notbase'))
658
 
        # open again, check it stuck.
659
 
        vf = self.get_file()
660
 
        self.assertEqual(['base'], vf.get_parents('notbase'))
661
 
        # and check the ghosts
662
 
        self.assertEqual(['base', 'stillghost'],
663
 
                         vf.get_parents_with_ghosts('notbase'))
 
787
        self.assertTrue(lines[('base\n', 'base')] > 0)
 
788
        self.assertTrue(lines[('lancestor\n', 'lancestor')] > 0)
 
789
        self.assertTrue(lines[('rancestor\n', 'rancestor')] > 0)
 
790
        self.assertTrue(lines[('child\n', 'child')] > 0)
 
791
        self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
664
792
 
665
793
    def test_add_lines_with_ghosts(self):
666
794
        # some versioned file formats allow lines to be added with parent
676
804
            vf.add_lines_with_ghosts('notbxbfse', [parent_id_utf8], [])
677
805
        except NotImplementedError:
678
806
            # check the other ghost apis are also not implemented
679
 
            self.assertRaises(NotImplementedError, vf.has_ghost, 'foo')
680
807
            self.assertRaises(NotImplementedError, vf.get_ancestry_with_ghosts, ['foo'])
681
808
            self.assertRaises(NotImplementedError, vf.get_parents_with_ghosts, 'foo')
682
 
            self.assertRaises(NotImplementedError, vf.get_graph_with_ghosts)
683
809
            return
684
810
        vf = self.reopen_file()
685
811
        # test key graph related apis: getncestry, _graph, get_parents
686
812
        # has_version
687
813
        # - these are ghost unaware and must not be reflect ghosts
688
814
        self.assertEqual(['notbxbfse'], vf.get_ancestry('notbxbfse'))
689
 
        self.assertEqual([], vf.get_parents('notbxbfse'))
690
 
        self.assertEqual({'notbxbfse':[]}, vf.get_graph())
691
 
        self.assertFalse(self.callDeprecated([osutils._revision_id_warning],
692
 
                         vf.has_version, parent_id_unicode))
693
815
        self.assertFalse(vf.has_version(parent_id_utf8))
694
816
        # we have _with_ghost apis to give us ghost information.
695
817
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry_with_ghosts(['notbxbfse']))
696
818
        self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
697
 
        self.assertEqual({'notbxbfse':[parent_id_utf8]}, vf.get_graph_with_ghosts())
698
 
        self.assertTrue(self.callDeprecated([osutils._revision_id_warning],
699
 
                        vf.has_ghost, parent_id_unicode))
700
 
        self.assertTrue(vf.has_ghost(parent_id_utf8))
701
819
        # if we add something that is a ghost of another, it should correct the
702
820
        # results of the prior apis
703
 
        self.callDeprecated([osutils._revision_id_warning],
704
 
                            vf.add_lines, parent_id_unicode, [], [])
 
821
        vf.add_lines(parent_id_utf8, [], [])
705
822
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry(['notbxbfse']))
706
 
        self.assertEqual([parent_id_utf8], vf.get_parents('notbxbfse'))
707
 
        self.assertEqual({parent_id_utf8:[],
708
 
                          'notbxbfse':[parent_id_utf8],
709
 
                          },
710
 
                         vf.get_graph())
711
 
        self.assertTrue(self.callDeprecated([osutils._revision_id_warning],
712
 
                        vf.has_version, parent_id_unicode))
 
823
        self.assertEqual({'notbxbfse':(parent_id_utf8,)},
 
824
            vf.get_parent_map(['notbxbfse']))
713
825
        self.assertTrue(vf.has_version(parent_id_utf8))
714
826
        # we have _with_ghost apis to give us ghost information.
715
 
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry_with_ghosts(['notbxbfse']))
 
827
        self.assertEqual([parent_id_utf8, 'notbxbfse'],
 
828
            vf.get_ancestry_with_ghosts(['notbxbfse']))
716
829
        self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
717
 
        self.assertEqual({parent_id_utf8:[],
718
 
                          'notbxbfse':[parent_id_utf8],
719
 
                          },
720
 
                         vf.get_graph_with_ghosts())
721
 
        self.assertFalse(self.callDeprecated([osutils._revision_id_warning],
722
 
                         vf.has_ghost, parent_id_unicode))
723
 
        self.assertFalse(vf.has_ghost(parent_id_utf8))
724
830
 
725
831
    def test_add_lines_with_ghosts_after_normal_revs(self):
726
832
        # some versioned file formats allow lines to be added with parent
730
836
        vf = self.get_file()
731
837
        # probe for ghost support
732
838
        try:
733
 
            vf.has_ghost('hoo')
 
839
            vf.add_lines_with_ghosts('base', [], ['line\n', 'line_b\n'])
734
840
        except NotImplementedError:
735
841
            return
736
 
        vf.add_lines_with_ghosts('base', [], ['line\n', 'line_b\n'])
737
842
        vf.add_lines_with_ghosts('references_ghost',
738
843
                                 ['base', 'a_ghost'],
739
844
                                 ['line\n', 'line_b\n', 'line_c\n'])
747
852
        factory = self.get_factory()
748
853
        vf = factory('id', transport, 0777, create=True, access_mode='w')
749
854
        vf = factory('id', transport, access_mode='r')
750
 
        self.assertRaises(errors.ReadOnlyError, vf.add_delta, '', [], '', '', False, [])
751
855
        self.assertRaises(errors.ReadOnlyError, vf.add_lines, 'base', [], [])
752
856
        self.assertRaises(errors.ReadOnlyError,
753
857
                          vf.add_lines_with_ghosts,
754
858
                          'base',
755
859
                          [],
756
860
                          [])
757
 
        self.assertRaises(errors.ReadOnlyError, vf.fix_parents, 'base', [])
758
 
        self.assertRaises(errors.ReadOnlyError, vf.join, 'base')
759
 
        self.assertRaises(errors.ReadOnlyError, vf.clone_text, 'base', 'bar', ['foo'])
760
 
    
761
 
    def test_get_sha1(self):
 
861
 
 
862
    def test_get_sha1s(self):
762
863
        # check the sha1 data is available
763
864
        vf = self.get_file()
764
865
        # a simple file
767
868
        vf.add_lines('b', ['a'], ['a\n'])
768
869
        # a file differing only in last newline.
769
870
        vf.add_lines('c', [], ['a'])
770
 
        self.assertEqual(
771
 
            '3f786850e387550fdab836ed7e6dc881de23001b', vf.get_sha1('a'))
772
 
        self.assertEqual(
773
 
            '3f786850e387550fdab836ed7e6dc881de23001b', vf.get_sha1('b'))
774
 
        self.assertEqual(
775
 
            '86f7e437faa5a7fce15d1ddcb9eaeaea377667b8', vf.get_sha1('c'))
776
 
        
777
 
 
778
 
class TestWeave(TestCaseWithTransport, VersionedFileTestMixIn):
 
871
        self.assertEqual({
 
872
            'a': '3f786850e387550fdab836ed7e6dc881de23001b',
 
873
            'c': '86f7e437faa5a7fce15d1ddcb9eaeaea377667b8',
 
874
            'b': '3f786850e387550fdab836ed7e6dc881de23001b',
 
875
            },
 
876
            vf.get_sha1s(['a', 'c', 'b']))
 
877
 
 
878
 
 
879
class TestWeave(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
779
880
 
780
881
    def get_file(self, name='foo'):
781
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
 
882
        return WeaveFile(name, get_transport(self.get_url('.')), create=True,
 
883
            get_scope=self.get_transaction)
782
884
 
783
885
    def get_file_corrupted_text(self):
784
 
        w = WeaveFile('foo', get_transport(self.get_url('.')), create=True)
 
886
        w = WeaveFile('foo', get_transport(self.get_url('.')), create=True,
 
887
            get_scope=self.get_transaction)
785
888
        w.add_lines('v1', [], ['hello\n'])
786
889
        w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
787
 
        
 
890
 
788
891
        # We are going to invasively corrupt the text
789
892
        # Make sure the internals of weave are the same
790
893
        self.assertEqual([('{', 0)
794
897
                        , 'there\n'
795
898
                        , ('}', None)
796
899
                        ], w._weave)
797
 
        
 
900
 
798
901
        self.assertEqual(['f572d396fae9206628714fb2ce00f72e94f2258f'
799
902
                        , '90f265c6e75f1c8f9ab76dcf85528352c5f215ef'
800
903
                        ], w._sha1s)
801
904
        w.check()
802
 
        
 
905
 
803
906
        # Corrupted
804
907
        w._weave[4] = 'There\n'
805
908
        return w
809
912
        # Corrected
810
913
        w._weave[4] = 'there\n'
811
914
        self.assertEqual('hello\nthere\n', w.get_text('v2'))
812
 
        
 
915
 
813
916
        #Invalid checksum, first digit changed
814
917
        w._sha1s[1] =  'f0f265c6e75f1c8f9ab76dcf85528352c5f215ef'
815
918
        return w
816
919
 
817
920
    def reopen_file(self, name='foo', create=False):
818
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=create)
 
921
        return WeaveFile(name, get_transport(self.get_url('.')), create=create,
 
922
            get_scope=self.get_transaction)
819
923
 
820
924
    def test_no_implicit_create(self):
821
925
        self.assertRaises(errors.NoSuchFile,
822
926
                          WeaveFile,
823
927
                          'foo',
824
 
                          get_transport(self.get_url('.')))
 
928
                          get_transport(self.get_url('.')),
 
929
                          get_scope=self.get_transaction)
825
930
 
826
931
    def get_factory(self):
827
932
        return WeaveFile
828
933
 
829
934
 
830
 
class TestKnit(TestCaseWithTransport, VersionedFileTestMixIn):
831
 
 
832
 
    def get_file(self, name='foo'):
833
 
        return KnitVersionedFile(name, get_transport(self.get_url('.')),
834
 
                                 delta=True, create=True)
835
 
 
836
 
    def get_factory(self):
837
 
        return KnitVersionedFile
838
 
 
839
 
    def get_file_corrupted_text(self):
840
 
        knit = self.get_file()
841
 
        knit.add_lines('v1', [], ['hello\n'])
842
 
        knit.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
843
 
        return knit
844
 
 
845
 
    def reopen_file(self, name='foo', create=False):
846
 
        return KnitVersionedFile(name, get_transport(self.get_url('.')),
847
 
            delta=True,
848
 
            create=create)
849
 
 
850
 
    def test_detection(self):
851
 
        knit = self.get_file()
852
 
        knit.check()
853
 
 
854
 
    def test_no_implicit_create(self):
855
 
        self.assertRaises(errors.NoSuchFile,
856
 
                          KnitVersionedFile,
857
 
                          'foo',
858
 
                          get_transport(self.get_url('.')))
859
 
 
860
 
 
861
 
class InterString(versionedfile.InterVersionedFile):
862
 
    """An inter-versionedfile optimised code path for strings.
863
 
 
864
 
    This is for use during testing where we use strings as versionedfiles
865
 
    so that none of the default regsitered interversionedfile classes will
866
 
    match - which lets us test the match logic.
867
 
    """
868
 
 
869
 
    @staticmethod
870
 
    def is_compatible(source, target):
871
 
        """InterString is compatible with strings-as-versionedfiles."""
872
 
        return isinstance(source, str) and isinstance(target, str)
873
 
 
874
 
 
875
 
# TODO this and the InterRepository core logic should be consolidatable
876
 
# if we make the registry a separate class though we still need to 
877
 
# test the behaviour in the active registry to catch failure-to-handle-
878
 
# stange-objects
879
 
class TestInterVersionedFile(TestCaseWithTransport):
880
 
 
881
 
    def test_get_default_inter_versionedfile(self):
882
 
        # test that the InterVersionedFile.get(a, b) probes
883
 
        # for a class where is_compatible(a, b) returns
884
 
        # true and returns a default interversionedfile otherwise.
885
 
        # This also tests that the default registered optimised interversionedfile
886
 
        # classes do not barf inappropriately when a surprising versionedfile type
887
 
        # is handed to them.
888
 
        dummy_a = "VersionedFile 1."
889
 
        dummy_b = "VersionedFile 2."
890
 
        self.assertGetsDefaultInterVersionedFile(dummy_a, dummy_b)
891
 
 
892
 
    def assertGetsDefaultInterVersionedFile(self, a, b):
893
 
        """Asserts that InterVersionedFile.get(a, b) -> the default."""
894
 
        inter = versionedfile.InterVersionedFile.get(a, b)
895
 
        self.assertEqual(versionedfile.InterVersionedFile,
896
 
                         inter.__class__)
897
 
        self.assertEqual(a, inter.source)
898
 
        self.assertEqual(b, inter.target)
899
 
 
900
 
    def test_register_inter_versionedfile_class(self):
901
 
        # test that a optimised code path provider - a
902
 
        # InterVersionedFile subclass can be registered and unregistered
903
 
        # and that it is correctly selected when given a versionedfile
904
 
        # pair that it returns true on for the is_compatible static method
905
 
        # check
906
 
        dummy_a = "VersionedFile 1."
907
 
        dummy_b = "VersionedFile 2."
908
 
        versionedfile.InterVersionedFile.register_optimiser(InterString)
909
 
        try:
910
 
            # we should get the default for something InterString returns False
911
 
            # to
912
 
            self.assertFalse(InterString.is_compatible(dummy_a, None))
913
 
            self.assertGetsDefaultInterVersionedFile(dummy_a, None)
914
 
            # and we should get an InterString for a pair it 'likes'
915
 
            self.assertTrue(InterString.is_compatible(dummy_a, dummy_b))
916
 
            inter = versionedfile.InterVersionedFile.get(dummy_a, dummy_b)
917
 
            self.assertEqual(InterString, inter.__class__)
918
 
            self.assertEqual(dummy_a, inter.source)
919
 
            self.assertEqual(dummy_b, inter.target)
920
 
        finally:
921
 
            versionedfile.InterVersionedFile.unregister_optimiser(InterString)
922
 
        # now we should get the default InterVersionedFile object again.
923
 
        self.assertGetsDefaultInterVersionedFile(dummy_a, dummy_b)
 
935
class TestPlanMergeVersionedFile(TestCaseWithMemoryTransport):
 
936
 
 
937
    def setUp(self):
 
938
        TestCaseWithMemoryTransport.setUp(self)
 
939
        mapper = PrefixMapper()
 
940
        factory = make_file_factory(True, mapper)
 
941
        self.vf1 = factory(self.get_transport('root-1'))
 
942
        self.vf2 = factory(self.get_transport('root-2'))
 
943
        self.plan_merge_vf = versionedfile._PlanMergeVersionedFile('root')
 
944
        self.plan_merge_vf.fallback_versionedfiles.extend([self.vf1, self.vf2])
 
945
 
 
946
    def test_add_lines(self):
 
947
        self.plan_merge_vf.add_lines(('root', 'a:'), [], [])
 
948
        self.assertRaises(ValueError, self.plan_merge_vf.add_lines,
 
949
            ('root', 'a'), [], [])
 
950
        self.assertRaises(ValueError, self.plan_merge_vf.add_lines,
 
951
            ('root', 'a:'), None, [])
 
952
        self.assertRaises(ValueError, self.plan_merge_vf.add_lines,
 
953
            ('root', 'a:'), [], None)
 
954
 
 
955
    def setup_abcde(self):
 
956
        self.vf1.add_lines(('root', 'A'), [], ['a'])
 
957
        self.vf1.add_lines(('root', 'B'), [('root', 'A')], ['b'])
 
958
        self.vf2.add_lines(('root', 'C'), [], ['c'])
 
959
        self.vf2.add_lines(('root', 'D'), [('root', 'C')], ['d'])
 
960
        self.plan_merge_vf.add_lines(('root', 'E:'),
 
961
            [('root', 'B'), ('root', 'D')], ['e'])
 
962
 
 
963
    def test_get_parents(self):
 
964
        self.setup_abcde()
 
965
        self.assertEqual({('root', 'B'):(('root', 'A'),)},
 
966
            self.plan_merge_vf.get_parent_map([('root', 'B')]))
 
967
        self.assertEqual({('root', 'D'):(('root', 'C'),)},
 
968
            self.plan_merge_vf.get_parent_map([('root', 'D')]))
 
969
        self.assertEqual({('root', 'E:'):(('root', 'B'),('root', 'D'))},
 
970
            self.plan_merge_vf.get_parent_map([('root', 'E:')]))
 
971
        self.assertEqual({},
 
972
            self.plan_merge_vf.get_parent_map([('root', 'F')]))
 
973
        self.assertEqual({
 
974
                ('root', 'B'):(('root', 'A'),),
 
975
                ('root', 'D'):(('root', 'C'),),
 
976
                ('root', 'E:'):(('root', 'B'),('root', 'D')),
 
977
                },
 
978
            self.plan_merge_vf.get_parent_map(
 
979
                [('root', 'B'), ('root', 'D'), ('root', 'E:'), ('root', 'F')]))
 
980
 
 
981
    def test_get_record_stream(self):
 
982
        self.setup_abcde()
 
983
        def get_record(suffix):
 
984
            return self.plan_merge_vf.get_record_stream(
 
985
                [('root', suffix)], 'unordered', True).next()
 
986
        self.assertEqual('a', get_record('A').get_bytes_as('fulltext'))
 
987
        self.assertEqual('c', get_record('C').get_bytes_as('fulltext'))
 
988
        self.assertEqual('e', get_record('E:').get_bytes_as('fulltext'))
 
989
        self.assertEqual('absent', get_record('F').storage_kind)
924
990
 
925
991
 
926
992
class TestReadonlyHttpMixin(object):
927
993
 
 
994
    def get_transaction(self):
 
995
        return 1
 
996
 
928
997
    def test_readonly_http_works(self):
929
998
        # we should be able to read from http with a versioned file.
930
999
        vf = self.get_file()
943
1012
class TestWeaveHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
944
1013
 
945
1014
    def get_file(self):
946
 
        return WeaveFile('foo', get_transport(self.get_url('.')), create=True)
 
1015
        return WeaveFile('foo', get_transport(self.get_url('.')), create=True,
 
1016
            get_scope=self.get_transaction)
947
1017
 
948
1018
    def get_factory(self):
949
1019
        return WeaveFile
950
1020
 
951
1021
 
952
 
class TestKnitHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
953
 
 
954
 
    def get_file(self):
955
 
        return KnitVersionedFile('foo', get_transport(self.get_url('.')),
956
 
                                 delta=True, create=True)
957
 
 
958
 
    def get_factory(self):
959
 
        return KnitVersionedFile
960
 
 
961
 
 
962
1022
class MergeCasesMixin(object):
963
1023
 
964
1024
    def doMerge(self, base, a, b, mp):
967
1027
 
968
1028
        def addcrlf(x):
969
1029
            return x + '\n'
970
 
        
 
1030
 
971
1031
        w = self.get_file()
972
1032
        w.add_lines('text0', [], map(addcrlf, base))
973
1033
        w.add_lines('text1', ['text0'], map(addcrlf, a))
989
1049
 
990
1050
        mp = map(addcrlf, mp)
991
1051
        self.assertEqual(mt.readlines(), mp)
992
 
        
993
 
        
 
1052
 
 
1053
 
994
1054
    def testOneInsert(self):
995
1055
        self.doMerge([],
996
1056
                     ['aa'],
1014
1074
                     ['aaa', 'xxx', 'yyy', 'bbb'],
1015
1075
                     ['aaa', 'xxx', 'bbb'], self.overlappedInsertExpected)
1016
1076
 
1017
 
        # really it ought to reduce this to 
 
1077
        # really it ought to reduce this to
1018
1078
        # ['aaa', 'xxx', 'yyy', 'bbb']
1019
1079
 
1020
1080
 
1022
1082
        self.doMerge(['aaa'],
1023
1083
                     ['xxx'],
1024
1084
                     ['yyy', 'zzz'],
1025
 
                     ['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz', 
 
1085
                     ['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz',
1026
1086
                      '>>>>>>> '])
1027
1087
 
1028
1088
    def testNonClashInsert1(self):
1029
1089
        self.doMerge(['aaa'],
1030
1090
                     ['xxx', 'aaa'],
1031
1091
                     ['yyy', 'zzz'],
1032
 
                     ['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz', 
 
1092
                     ['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz',
1033
1093
                      '>>>>>>> '])
1034
1094
 
1035
1095
    def testNonClashInsert2(self):
1049
1109
        #######################################
1050
1110
        # skippd, not working yet
1051
1111
        return
1052
 
        
 
1112
 
1053
1113
        self.doMerge(['aaa', 'bbb', 'ccc'],
1054
1114
                     ['aaa', 'ddd', 'ccc'],
1055
1115
                     ['aaa', 'ccc'],
1092
1152
            """
1093
1153
        result = """\
1094
1154
            line 1
 
1155
<<<<<<<\x20
 
1156
            line 2
 
1157
=======
 
1158
>>>>>>>\x20
1095
1159
            """
1096
1160
        self._test_merge_from_strings(base, a, b, result)
1097
1161
 
1098
1162
    def test_deletion_overlap(self):
1099
1163
        """Delete overlapping regions with no other conflict.
1100
1164
 
1101
 
        Arguably it'd be better to treat these as agreement, rather than 
 
1165
        Arguably it'd be better to treat these as agreement, rather than
1102
1166
        conflict, but for now conflict is safer.
1103
1167
        """
1104
1168
        base = """\
1120
1184
            """
1121
1185
        result = """\
1122
1186
            start context
1123
 
<<<<<<< 
 
1187
<<<<<<<\x20
1124
1188
            int a() {}
1125
1189
=======
1126
1190
            int c() {}
1127
 
>>>>>>> 
 
1191
>>>>>>>\x20
1128
1192
            end context
1129
1193
            """
1130
1194
        self._test_merge_from_strings(base, a, b, result)
1156
1220
 
1157
1221
    def test_sync_on_deletion(self):
1158
1222
        """Specific case of merge where we can synchronize incorrectly.
1159
 
        
 
1223
 
1160
1224
        A previous version of the weave merge concluded that the two versions
1161
1225
        agreed on deleting line 2, and this could be a synchronization point.
1162
 
        Line 1 was then considered in isolation, and thought to be deleted on 
 
1226
        Line 1 was then considered in isolation, and thought to be deleted on
1163
1227
        both sides.
1164
1228
 
1165
1229
        It's better to consider the whole thing as a disagreement region.
1184
1248
            """
1185
1249
        result = """\
1186
1250
            start context
1187
 
<<<<<<< 
 
1251
<<<<<<<\x20
1188
1252
            base line 1
1189
1253
            a's replacement line 2
1190
1254
=======
1191
1255
            b replaces
1192
1256
            both lines
1193
 
>>>>>>> 
 
1257
>>>>>>>\x20
1194
1258
            end context
1195
1259
            """
1196
1260
        self._test_merge_from_strings(base, a, b, result)
1197
1261
 
1198
1262
 
1199
 
class TestKnitMerge(TestCaseWithTransport, MergeCasesMixin):
1200
 
 
1201
 
    def get_file(self, name='foo'):
1202
 
        return KnitVersionedFile(name, get_transport(self.get_url('.')),
1203
 
                                 delta=True, create=True)
1204
 
 
1205
 
    def log_contents(self, w):
1206
 
        pass
1207
 
 
1208
 
 
1209
 
class TestWeaveMerge(TestCaseWithTransport, MergeCasesMixin):
 
1263
class TestWeaveMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1210
1264
 
1211
1265
    def get_file(self, name='foo'):
1212
1266
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
1217
1271
        write_weave(w, tmpf)
1218
1272
        self.log(tmpf.getvalue())
1219
1273
 
1220
 
    overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======', 
 
1274
    overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======',
1221
1275
                                'xxx', '>>>>>>> ', 'bbb']
 
1276
 
 
1277
 
 
1278
class TestContentFactoryAdaption(TestCaseWithMemoryTransport):
 
1279
 
 
1280
    def test_select_adaptor(self):
 
1281
        """Test expected adapters exist."""
 
1282
        # One scenario for each lookup combination we expect to use.
 
1283
        # Each is source_kind, requested_kind, adapter class
 
1284
        scenarios = [
 
1285
            ('knit-delta-gz', 'fulltext', _mod_knit.DeltaPlainToFullText),
 
1286
            ('knit-ft-gz', 'fulltext', _mod_knit.FTPlainToFullText),
 
1287
            ('knit-annotated-delta-gz', 'knit-delta-gz',
 
1288
                _mod_knit.DeltaAnnotatedToUnannotated),
 
1289
            ('knit-annotated-delta-gz', 'fulltext',
 
1290
                _mod_knit.DeltaAnnotatedToFullText),
 
1291
            ('knit-annotated-ft-gz', 'knit-ft-gz',
 
1292
                _mod_knit.FTAnnotatedToUnannotated),
 
1293
            ('knit-annotated-ft-gz', 'fulltext',
 
1294
                _mod_knit.FTAnnotatedToFullText),
 
1295
            ]
 
1296
        for source, requested, klass in scenarios:
 
1297
            adapter_factory = versionedfile.adapter_registry.get(
 
1298
                (source, requested))
 
1299
            adapter = adapter_factory(None)
 
1300
            self.assertIsInstance(adapter, klass)
 
1301
 
 
1302
    def get_knit(self, annotated=True):
 
1303
        mapper = ConstantMapper('knit')
 
1304
        transport = self.get_transport()
 
1305
        return make_file_factory(annotated, mapper)(transport)
 
1306
 
 
1307
    def helpGetBytes(self, f, ft_adapter, delta_adapter):
 
1308
        """Grab the interested adapted texts for tests."""
 
1309
        # origin is a fulltext
 
1310
        entries = f.get_record_stream([('origin',)], 'unordered', False)
 
1311
        base = entries.next()
 
1312
        ft_data = ft_adapter.get_bytes(base)
 
1313
        # merged is both a delta and multiple parents.
 
1314
        entries = f.get_record_stream([('merged',)], 'unordered', False)
 
1315
        merged = entries.next()
 
1316
        delta_data = delta_adapter.get_bytes(merged)
 
1317
        return ft_data, delta_data
 
1318
 
 
1319
    def test_deannotation_noeol(self):
 
1320
        """Test converting annotated knits to unannotated knits."""
 
1321
        # we need a full text, and a delta
 
1322
        f = self.get_knit()
 
1323
        get_diamond_files(f, 1, trailing_eol=False)
 
1324
        ft_data, delta_data = self.helpGetBytes(f,
 
1325
            _mod_knit.FTAnnotatedToUnannotated(None),
 
1326
            _mod_knit.DeltaAnnotatedToUnannotated(None))
 
1327
        self.assertEqual(
 
1328
            'version origin 1 b284f94827db1fa2970d9e2014f080413b547a7e\n'
 
1329
            'origin\n'
 
1330
            'end origin\n',
 
1331
            GzipFile(mode='rb', fileobj=StringIO(ft_data)).read())
 
1332
        self.assertEqual(
 
1333
            'version merged 4 32c2e79763b3f90e8ccde37f9710b6629c25a796\n'
 
1334
            '1,2,3\nleft\nright\nmerged\nend merged\n',
 
1335
            GzipFile(mode='rb', fileobj=StringIO(delta_data)).read())
 
1336
 
 
1337
    def test_deannotation(self):
 
1338
        """Test converting annotated knits to unannotated knits."""
 
1339
        # we need a full text, and a delta
 
1340
        f = self.get_knit()
 
1341
        get_diamond_files(f, 1)
 
1342
        ft_data, delta_data = self.helpGetBytes(f,
 
1343
            _mod_knit.FTAnnotatedToUnannotated(None),
 
1344
            _mod_knit.DeltaAnnotatedToUnannotated(None))
 
1345
        self.assertEqual(
 
1346
            'version origin 1 00e364d235126be43292ab09cb4686cf703ddc17\n'
 
1347
            'origin\n'
 
1348
            'end origin\n',
 
1349
            GzipFile(mode='rb', fileobj=StringIO(ft_data)).read())
 
1350
        self.assertEqual(
 
1351
            'version merged 3 ed8bce375198ea62444dc71952b22cfc2b09226d\n'
 
1352
            '2,2,2\nright\nmerged\nend merged\n',
 
1353
            GzipFile(mode='rb', fileobj=StringIO(delta_data)).read())
 
1354
 
 
1355
    def test_annotated_to_fulltext_no_eol(self):
 
1356
        """Test adapting annotated knits to full texts (for -> weaves)."""
 
1357
        # we need a full text, and a delta
 
1358
        f = self.get_knit()
 
1359
        get_diamond_files(f, 1, trailing_eol=False)
 
1360
        # Reconstructing a full text requires a backing versioned file, and it
 
1361
        # must have the base lines requested from it.
 
1362
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
 
1363
        ft_data, delta_data = self.helpGetBytes(f,
 
1364
            _mod_knit.FTAnnotatedToFullText(None),
 
1365
            _mod_knit.DeltaAnnotatedToFullText(logged_vf))
 
1366
        self.assertEqual('origin', ft_data)
 
1367
        self.assertEqual('base\nleft\nright\nmerged', delta_data)
 
1368
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
 
1369
            True)], logged_vf.calls)
 
1370
 
 
1371
    def test_annotated_to_fulltext(self):
 
1372
        """Test adapting annotated knits to full texts (for -> weaves)."""
 
1373
        # we need a full text, and a delta
 
1374
        f = self.get_knit()
 
1375
        get_diamond_files(f, 1)
 
1376
        # Reconstructing a full text requires a backing versioned file, and it
 
1377
        # must have the base lines requested from it.
 
1378
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
 
1379
        ft_data, delta_data = self.helpGetBytes(f,
 
1380
            _mod_knit.FTAnnotatedToFullText(None),
 
1381
            _mod_knit.DeltaAnnotatedToFullText(logged_vf))
 
1382
        self.assertEqual('origin\n', ft_data)
 
1383
        self.assertEqual('base\nleft\nright\nmerged\n', delta_data)
 
1384
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
 
1385
            True)], logged_vf.calls)
 
1386
 
 
1387
    def test_unannotated_to_fulltext(self):
 
1388
        """Test adapting unannotated knits to full texts.
 
1389
 
 
1390
        This is used for -> weaves, and for -> annotated knits.
 
1391
        """
 
1392
        # we need a full text, and a delta
 
1393
        f = self.get_knit(annotated=False)
 
1394
        get_diamond_files(f, 1)
 
1395
        # Reconstructing a full text requires a backing versioned file, and it
 
1396
        # must have the base lines requested from it.
 
1397
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
 
1398
        ft_data, delta_data = self.helpGetBytes(f,
 
1399
            _mod_knit.FTPlainToFullText(None),
 
1400
            _mod_knit.DeltaPlainToFullText(logged_vf))
 
1401
        self.assertEqual('origin\n', ft_data)
 
1402
        self.assertEqual('base\nleft\nright\nmerged\n', delta_data)
 
1403
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
 
1404
            True)], logged_vf.calls)
 
1405
 
 
1406
    def test_unannotated_to_fulltext_no_eol(self):
 
1407
        """Test adapting unannotated knits to full texts.
 
1408
 
 
1409
        This is used for -> weaves, and for -> annotated knits.
 
1410
        """
 
1411
        # we need a full text, and a delta
 
1412
        f = self.get_knit(annotated=False)
 
1413
        get_diamond_files(f, 1, trailing_eol=False)
 
1414
        # Reconstructing a full text requires a backing versioned file, and it
 
1415
        # must have the base lines requested from it.
 
1416
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
 
1417
        ft_data, delta_data = self.helpGetBytes(f,
 
1418
            _mod_knit.FTPlainToFullText(None),
 
1419
            _mod_knit.DeltaPlainToFullText(logged_vf))
 
1420
        self.assertEqual('origin', ft_data)
 
1421
        self.assertEqual('base\nleft\nright\nmerged', delta_data)
 
1422
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
 
1423
            True)], logged_vf.calls)
 
1424
 
 
1425
 
 
1426
class TestKeyMapper(TestCaseWithMemoryTransport):
 
1427
    """Tests for various key mapping logic."""
 
1428
 
 
1429
    def test_identity_mapper(self):
 
1430
        mapper = versionedfile.ConstantMapper("inventory")
 
1431
        self.assertEqual("inventory", mapper.map(('foo@ar',)))
 
1432
        self.assertEqual("inventory", mapper.map(('quux',)))
 
1433
 
 
1434
    def test_prefix_mapper(self):
 
1435
        #format5: plain
 
1436
        mapper = versionedfile.PrefixMapper()
 
1437
        self.assertEqual("file-id", mapper.map(("file-id", "revision-id")))
 
1438
        self.assertEqual("new-id", mapper.map(("new-id", "revision-id")))
 
1439
        self.assertEqual(('file-id',), mapper.unmap("file-id"))
 
1440
        self.assertEqual(('new-id',), mapper.unmap("new-id"))
 
1441
 
 
1442
    def test_hash_prefix_mapper(self):
 
1443
        #format6: hash + plain
 
1444
        mapper = versionedfile.HashPrefixMapper()
 
1445
        self.assertEqual("9b/file-id", mapper.map(("file-id", "revision-id")))
 
1446
        self.assertEqual("45/new-id", mapper.map(("new-id", "revision-id")))
 
1447
        self.assertEqual(('file-id',), mapper.unmap("9b/file-id"))
 
1448
        self.assertEqual(('new-id',), mapper.unmap("45/new-id"))
 
1449
 
 
1450
    def test_hash_escaped_mapper(self):
 
1451
        #knit1: hash + escaped
 
1452
        mapper = versionedfile.HashEscapedPrefixMapper()
 
1453
        self.assertEqual("88/%2520", mapper.map((" ", "revision-id")))
 
1454
        self.assertEqual("ed/fil%2545-%2549d", mapper.map(("filE-Id",
 
1455
            "revision-id")))
 
1456
        self.assertEqual("88/ne%2557-%2549d", mapper.map(("neW-Id",
 
1457
            "revision-id")))
 
1458
        self.assertEqual(('filE-Id',), mapper.unmap("ed/fil%2545-%2549d"))
 
1459
        self.assertEqual(('neW-Id',), mapper.unmap("88/ne%2557-%2549d"))
 
1460
 
 
1461
 
 
1462
class TestVersionedFiles(TestCaseWithMemoryTransport):
 
1463
    """Tests for the multiple-file variant of VersionedFile."""
 
1464
 
 
1465
    def get_versionedfiles(self, relpath='files'):
 
1466
        transport = self.get_transport(relpath)
 
1467
        if relpath != '.':
 
1468
            transport.mkdir('.')
 
1469
        files = self.factory(transport)
 
1470
        if self.cleanup is not None:
 
1471
            self.addCleanup(lambda:self.cleanup(files))
 
1472
        return files
 
1473
 
 
1474
    def test_annotate(self):
 
1475
        files = self.get_versionedfiles()
 
1476
        self.get_diamond_files(files)
 
1477
        if self.key_length == 1:
 
1478
            prefix = ()
 
1479
        else:
 
1480
            prefix = ('FileA',)
 
1481
        # introduced full text
 
1482
        origins = files.annotate(prefix + ('origin',))
 
1483
        self.assertEqual([
 
1484
            (prefix + ('origin',), 'origin\n')],
 
1485
            origins)
 
1486
        # a delta
 
1487
        origins = files.annotate(prefix + ('base',))
 
1488
        self.assertEqual([
 
1489
            (prefix + ('base',), 'base\n')],
 
1490
            origins)
 
1491
        # a merge
 
1492
        origins = files.annotate(prefix + ('merged',))
 
1493
        if self.graph:
 
1494
            self.assertEqual([
 
1495
                (prefix + ('base',), 'base\n'),
 
1496
                (prefix + ('left',), 'left\n'),
 
1497
                (prefix + ('right',), 'right\n'),
 
1498
                (prefix + ('merged',), 'merged\n')
 
1499
                ],
 
1500
                origins)
 
1501
        else:
 
1502
            # Without a graph everything is new.
 
1503
            self.assertEqual([
 
1504
                (prefix + ('merged',), 'base\n'),
 
1505
                (prefix + ('merged',), 'left\n'),
 
1506
                (prefix + ('merged',), 'right\n'),
 
1507
                (prefix + ('merged',), 'merged\n')
 
1508
                ],
 
1509
                origins)
 
1510
        self.assertRaises(RevisionNotPresent,
 
1511
            files.annotate, prefix + ('missing-key',))
 
1512
 
 
1513
    def test_construct(self):
 
1514
        """Each parameterised test can be constructed on a transport."""
 
1515
        files = self.get_versionedfiles()
 
1516
 
 
1517
    def get_diamond_files(self, files, trailing_eol=True, left_only=False,
 
1518
        nokeys=False):
 
1519
        return get_diamond_files(files, self.key_length,
 
1520
            trailing_eol=trailing_eol, nograph=not self.graph,
 
1521
            left_only=left_only, nokeys=nokeys)
 
1522
 
 
1523
    def test_add_lines_nostoresha(self):
 
1524
        """When nostore_sha is supplied using old content raises."""
 
1525
        vf = self.get_versionedfiles()
 
1526
        empty_text = ('a', [])
 
1527
        sample_text_nl = ('b', ["foo\n", "bar\n"])
 
1528
        sample_text_no_nl = ('c', ["foo\n", "bar"])
 
1529
        shas = []
 
1530
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
 
1531
            sha, _, _ = vf.add_lines(self.get_simple_key(version), [], lines)
 
1532
            shas.append(sha)
 
1533
        # we now have a copy of all the lines in the vf.
 
1534
        for sha, (version, lines) in zip(
 
1535
            shas, (empty_text, sample_text_nl, sample_text_no_nl)):
 
1536
            new_key = self.get_simple_key(version + "2")
 
1537
            self.assertRaises(errors.ExistingContent,
 
1538
                vf.add_lines, new_key, [], lines,
 
1539
                nostore_sha=sha)
 
1540
            # and no new version should have been added.
 
1541
            record = vf.get_record_stream([new_key], 'unordered', True).next()
 
1542
            self.assertEqual('absent', record.storage_kind)
 
1543
 
 
1544
    def test_add_lines_return(self):
 
1545
        files = self.get_versionedfiles()
 
1546
        # save code by using the stock data insertion helper.
 
1547
        adds = self.get_diamond_files(files)
 
1548
        results = []
 
1549
        # We can only validate the first 2 elements returned from add_lines.
 
1550
        for add in adds:
 
1551
            self.assertEqual(3, len(add))
 
1552
            results.append(add[:2])
 
1553
        if self.key_length == 1:
 
1554
            self.assertEqual([
 
1555
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
 
1556
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
 
1557
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
 
1558
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
 
1559
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
 
1560
                results)
 
1561
        elif self.key_length == 2:
 
1562
            self.assertEqual([
 
1563
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
 
1564
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
 
1565
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
 
1566
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
 
1567
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
 
1568
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
 
1569
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
 
1570
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
 
1571
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23),
 
1572
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
 
1573
                results)
 
1574
 
 
1575
    def test_add_lines_no_key_generates_chk_key(self):
 
1576
        files = self.get_versionedfiles()
 
1577
        # save code by using the stock data insertion helper.
 
1578
        adds = self.get_diamond_files(files, nokeys=True)
 
1579
        results = []
 
1580
        # We can only validate the first 2 elements returned from add_lines.
 
1581
        for add in adds:
 
1582
            self.assertEqual(3, len(add))
 
1583
            results.append(add[:2])
 
1584
        if self.key_length == 1:
 
1585
            self.assertEqual([
 
1586
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
 
1587
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
 
1588
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
 
1589
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
 
1590
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
 
1591
                results)
 
1592
            # Check the added items got CHK keys.
 
1593
            self.assertEqual(set([
 
1594
                ('sha1:00e364d235126be43292ab09cb4686cf703ddc17',),
 
1595
                ('sha1:51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44',),
 
1596
                ('sha1:9ef09dfa9d86780bdec9219a22560c6ece8e0ef1',),
 
1597
                ('sha1:a8478686da38e370e32e42e8a0c220e33ee9132f',),
 
1598
                ('sha1:ed8bce375198ea62444dc71952b22cfc2b09226d',),
 
1599
                ]),
 
1600
                files.keys())
 
1601
        elif self.key_length == 2:
 
1602
            self.assertEqual([
 
1603
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
 
1604
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
 
1605
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
 
1606
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
 
1607
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
 
1608
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
 
1609
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
 
1610
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
 
1611
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23),
 
1612
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
 
1613
                results)
 
1614
            # Check the added items got CHK keys.
 
1615
            self.assertEqual(set([
 
1616
                ('FileA', 'sha1:00e364d235126be43292ab09cb4686cf703ddc17'),
 
1617
                ('FileA', 'sha1:51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44'),
 
1618
                ('FileA', 'sha1:9ef09dfa9d86780bdec9219a22560c6ece8e0ef1'),
 
1619
                ('FileA', 'sha1:a8478686da38e370e32e42e8a0c220e33ee9132f'),
 
1620
                ('FileA', 'sha1:ed8bce375198ea62444dc71952b22cfc2b09226d'),
 
1621
                ('FileB', 'sha1:00e364d235126be43292ab09cb4686cf703ddc17'),
 
1622
                ('FileB', 'sha1:51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44'),
 
1623
                ('FileB', 'sha1:9ef09dfa9d86780bdec9219a22560c6ece8e0ef1'),
 
1624
                ('FileB', 'sha1:a8478686da38e370e32e42e8a0c220e33ee9132f'),
 
1625
                ('FileB', 'sha1:ed8bce375198ea62444dc71952b22cfc2b09226d'),
 
1626
                ]),
 
1627
                files.keys())
 
1628
 
 
1629
    def test_empty_lines(self):
 
1630
        """Empty files can be stored."""
 
1631
        f = self.get_versionedfiles()
 
1632
        key_a = self.get_simple_key('a')
 
1633
        f.add_lines(key_a, [], [])
 
1634
        self.assertEqual('',
 
1635
            f.get_record_stream([key_a], 'unordered', True
 
1636
                ).next().get_bytes_as('fulltext'))
 
1637
        key_b = self.get_simple_key('b')
 
1638
        f.add_lines(key_b, self.get_parents([key_a]), [])
 
1639
        self.assertEqual('',
 
1640
            f.get_record_stream([key_b], 'unordered', True
 
1641
                ).next().get_bytes_as('fulltext'))
 
1642
 
 
1643
    def test_newline_only(self):
 
1644
        f = self.get_versionedfiles()
 
1645
        key_a = self.get_simple_key('a')
 
1646
        f.add_lines(key_a, [], ['\n'])
 
1647
        self.assertEqual('\n',
 
1648
            f.get_record_stream([key_a], 'unordered', True
 
1649
                ).next().get_bytes_as('fulltext'))
 
1650
        key_b = self.get_simple_key('b')
 
1651
        f.add_lines(key_b, self.get_parents([key_a]), ['\n'])
 
1652
        self.assertEqual('\n',
 
1653
            f.get_record_stream([key_b], 'unordered', True
 
1654
                ).next().get_bytes_as('fulltext'))
 
1655
 
 
1656
    def test_get_record_stream_empty(self):
 
1657
        """An empty stream can be requested without error."""
 
1658
        f = self.get_versionedfiles()
 
1659
        entries = f.get_record_stream([], 'unordered', False)
 
1660
        self.assertEqual([], list(entries))
 
1661
 
 
1662
    def assertValidStorageKind(self, storage_kind):
 
1663
        """Assert that storage_kind is a valid storage_kind."""
 
1664
        self.assertSubset([storage_kind],
 
1665
            ['mpdiff', 'knit-annotated-ft', 'knit-annotated-delta',
 
1666
             'knit-ft', 'knit-delta', 'chunked', 'fulltext',
 
1667
             'knit-annotated-ft-gz', 'knit-annotated-delta-gz', 'knit-ft-gz',
 
1668
             'knit-delta-gz',
 
1669
             'knit-delta-closure', 'knit-delta-closure-ref',
 
1670
             'groupcompress-block', 'groupcompress-block-ref'])
 
1671
 
 
1672
    def capture_stream(self, f, entries, on_seen, parents):
 
1673
        """Capture a stream for testing."""
 
1674
        for factory in entries:
 
1675
            on_seen(factory.key)
 
1676
            self.assertValidStorageKind(factory.storage_kind)
 
1677
            if factory.sha1 is not None:
 
1678
                self.assertEqual(f.get_sha1s([factory.key])[factory.key],
 
1679
                    factory.sha1)
 
1680
            self.assertEqual(parents[factory.key], factory.parents)
 
1681
            self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
 
1682
                str)
 
1683
 
 
1684
    def test_get_record_stream_interface(self):
 
1685
        """each item in a stream has to provide a regular interface."""
 
1686
        files = self.get_versionedfiles()
 
1687
        self.get_diamond_files(files)
 
1688
        keys, _ = self.get_keys_and_sort_order()
 
1689
        parent_map = files.get_parent_map(keys)
 
1690
        entries = files.get_record_stream(keys, 'unordered', False)
 
1691
        seen = set()
 
1692
        self.capture_stream(files, entries, seen.add, parent_map)
 
1693
        self.assertEqual(set(keys), seen)
 
1694
 
 
1695
    def get_simple_key(self, suffix):
 
1696
        """Return a key for the object under test."""
 
1697
        if self.key_length == 1:
 
1698
            return (suffix,)
 
1699
        else:
 
1700
            return ('FileA',) + (suffix,)
 
1701
 
 
1702
    def get_keys_and_sort_order(self):
 
1703
        """Get diamond test keys list, and their sort ordering."""
 
1704
        if self.key_length == 1:
 
1705
            keys = [('merged',), ('left',), ('right',), ('base',)]
 
1706
            sort_order = {('merged',):2, ('left',):1, ('right',):1, ('base',):0}
 
1707
        else:
 
1708
            keys = [
 
1709
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
 
1710
                ('FileA', 'base'),
 
1711
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
 
1712
                ('FileB', 'base'),
 
1713
                ]
 
1714
            sort_order = {
 
1715
                ('FileA', 'merged'):2, ('FileA', 'left'):1, ('FileA', 'right'):1,
 
1716
                ('FileA', 'base'):0,
 
1717
                ('FileB', 'merged'):2, ('FileB', 'left'):1, ('FileB', 'right'):1,
 
1718
                ('FileB', 'base'):0,
 
1719
                }
 
1720
        return keys, sort_order
 
1721
 
 
1722
    def get_keys_and_groupcompress_sort_order(self):
 
1723
        """Get diamond test keys list, and their groupcompress sort ordering."""
 
1724
        if self.key_length == 1:
 
1725
            keys = [('merged',), ('left',), ('right',), ('base',)]
 
1726
            sort_order = {('merged',):0, ('left',):1, ('right',):1, ('base',):2}
 
1727
        else:
 
1728
            keys = [
 
1729
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
 
1730
                ('FileA', 'base'),
 
1731
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
 
1732
                ('FileB', 'base'),
 
1733
                ]
 
1734
            sort_order = {
 
1735
                ('FileA', 'merged'):0, ('FileA', 'left'):1, ('FileA', 'right'):1,
 
1736
                ('FileA', 'base'):2,
 
1737
                ('FileB', 'merged'):3, ('FileB', 'left'):4, ('FileB', 'right'):4,
 
1738
                ('FileB', 'base'):5,
 
1739
                }
 
1740
        return keys, sort_order
 
1741
 
 
1742
    def test_get_record_stream_interface_ordered(self):
 
1743
        """each item in a stream has to provide a regular interface."""
 
1744
        files = self.get_versionedfiles()
 
1745
        self.get_diamond_files(files)
 
1746
        keys, sort_order = self.get_keys_and_sort_order()
 
1747
        parent_map = files.get_parent_map(keys)
 
1748
        entries = files.get_record_stream(keys, 'topological', False)
 
1749
        seen = []
 
1750
        self.capture_stream(files, entries, seen.append, parent_map)
 
1751
        self.assertStreamOrder(sort_order, seen, keys)
 
1752
 
 
1753
    def test_get_record_stream_interface_ordered_with_delta_closure(self):
 
1754
        """each item must be accessible as a fulltext."""
 
1755
        files = self.get_versionedfiles()
 
1756
        self.get_diamond_files(files)
 
1757
        keys, sort_order = self.get_keys_and_sort_order()
 
1758
        parent_map = files.get_parent_map(keys)
 
1759
        entries = files.get_record_stream(keys, 'topological', True)
 
1760
        seen = []
 
1761
        for factory in entries:
 
1762
            seen.append(factory.key)
 
1763
            self.assertValidStorageKind(factory.storage_kind)
 
1764
            self.assertSubset([factory.sha1],
 
1765
                [None, files.get_sha1s([factory.key])[factory.key]])
 
1766
            self.assertEqual(parent_map[factory.key], factory.parents)
 
1767
            # self.assertEqual(files.get_text(factory.key),
 
1768
            ft_bytes = factory.get_bytes_as('fulltext')
 
1769
            self.assertIsInstance(ft_bytes, str)
 
1770
            chunked_bytes = factory.get_bytes_as('chunked')
 
1771
            self.assertEqualDiff(ft_bytes, ''.join(chunked_bytes))
 
1772
 
 
1773
        self.assertStreamOrder(sort_order, seen, keys)
 
1774
 
 
1775
    def test_get_record_stream_interface_groupcompress(self):
 
1776
        """each item in a stream has to provide a regular interface."""
 
1777
        files = self.get_versionedfiles()
 
1778
        self.get_diamond_files(files)
 
1779
        keys, sort_order = self.get_keys_and_groupcompress_sort_order()
 
1780
        parent_map = files.get_parent_map(keys)
 
1781
        entries = files.get_record_stream(keys, 'groupcompress', False)
 
1782
        seen = []
 
1783
        self.capture_stream(files, entries, seen.append, parent_map)
 
1784
        self.assertStreamOrder(sort_order, seen, keys)
 
1785
 
 
1786
    def assertStreamOrder(self, sort_order, seen, keys):
 
1787
        self.assertEqual(len(set(seen)), len(keys))
 
1788
        if self.key_length == 1:
 
1789
            lows = {():0}
 
1790
        else:
 
1791
            lows = {('FileA',):0, ('FileB',):0}
 
1792
        if not self.graph:
 
1793
            self.assertEqual(set(keys), set(seen))
 
1794
        else:
 
1795
            for key in seen:
 
1796
                sort_pos = sort_order[key]
 
1797
                self.assertTrue(sort_pos >= lows[key[:-1]],
 
1798
                    "Out of order in sorted stream: %r, %r" % (key, seen))
 
1799
                lows[key[:-1]] = sort_pos
 
1800
 
 
1801
    def test_get_record_stream_unknown_storage_kind_raises(self):
 
1802
        """Asking for a storage kind that the stream cannot supply raises."""
 
1803
        files = self.get_versionedfiles()
 
1804
        self.get_diamond_files(files)
 
1805
        if self.key_length == 1:
 
1806
            keys = [('merged',), ('left',), ('right',), ('base',)]
 
1807
        else:
 
1808
            keys = [
 
1809
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
 
1810
                ('FileA', 'base'),
 
1811
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
 
1812
                ('FileB', 'base'),
 
1813
                ]
 
1814
        parent_map = files.get_parent_map(keys)
 
1815
        entries = files.get_record_stream(keys, 'unordered', False)
 
1816
        # We track the contents because we should be able to try, fail a
 
1817
        # particular kind and then ask for one that works and continue.
 
1818
        seen = set()
 
1819
        for factory in entries:
 
1820
            seen.add(factory.key)
 
1821
            self.assertValidStorageKind(factory.storage_kind)
 
1822
            if factory.sha1 is not None:
 
1823
                self.assertEqual(files.get_sha1s([factory.key])[factory.key],
 
1824
                                 factory.sha1)
 
1825
            self.assertEqual(parent_map[factory.key], factory.parents)
 
1826
            # currently no stream emits mpdiff
 
1827
            self.assertRaises(errors.UnavailableRepresentation,
 
1828
                factory.get_bytes_as, 'mpdiff')
 
1829
            self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
 
1830
                str)
 
1831
        self.assertEqual(set(keys), seen)
 
1832
 
 
1833
    def test_get_record_stream_missing_records_are_absent(self):
 
1834
        files = self.get_versionedfiles()
 
1835
        self.get_diamond_files(files)
 
1836
        if self.key_length == 1:
 
1837
            keys = [('merged',), ('left',), ('right',), ('absent',), ('base',)]
 
1838
        else:
 
1839
            keys = [
 
1840
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
 
1841
                ('FileA', 'absent'), ('FileA', 'base'),
 
1842
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
 
1843
                ('FileB', 'absent'), ('FileB', 'base'),
 
1844
                ('absent', 'absent'),
 
1845
                ]
 
1846
        parent_map = files.get_parent_map(keys)
 
1847
        entries = files.get_record_stream(keys, 'unordered', False)
 
1848
        self.assertAbsentRecord(files, keys, parent_map, entries)
 
1849
        entries = files.get_record_stream(keys, 'topological', False)
 
1850
        self.assertAbsentRecord(files, keys, parent_map, entries)
 
1851
 
 
1852
    def assertRecordHasContent(self, record, bytes):
 
1853
        """Assert that record has the bytes bytes."""
 
1854
        self.assertEqual(bytes, record.get_bytes_as('fulltext'))
 
1855
        self.assertEqual(bytes, ''.join(record.get_bytes_as('chunked')))
 
1856
 
 
1857
    def test_get_record_stream_native_formats_are_wire_ready_one_ft(self):
 
1858
        files = self.get_versionedfiles()
 
1859
        key = self.get_simple_key('foo')
 
1860
        files.add_lines(key, (), ['my text\n', 'content'])
 
1861
        stream = files.get_record_stream([key], 'unordered', False)
 
1862
        record = stream.next()
 
1863
        if record.storage_kind in ('chunked', 'fulltext'):
 
1864
            # chunked and fulltext representations are for direct use not wire
 
1865
            # serialisation: check they are able to be used directly. To send
 
1866
            # such records over the wire translation will be needed.
 
1867
            self.assertRecordHasContent(record, "my text\ncontent")
 
1868
        else:
 
1869
            bytes = [record.get_bytes_as(record.storage_kind)]
 
1870
            network_stream = versionedfile.NetworkRecordStream(bytes).read()
 
1871
            source_record = record
 
1872
            records = []
 
1873
            for record in network_stream:
 
1874
                records.append(record)
 
1875
                self.assertEqual(source_record.storage_kind,
 
1876
                    record.storage_kind)
 
1877
                self.assertEqual(source_record.parents, record.parents)
 
1878
                self.assertEqual(
 
1879
                    source_record.get_bytes_as(source_record.storage_kind),
 
1880
                    record.get_bytes_as(record.storage_kind))
 
1881
            self.assertEqual(1, len(records))
 
1882
 
 
1883
    def assertStreamMetaEqual(self, records, expected, stream):
 
1884
        """Assert that streams expected and stream have the same records.
 
1885
 
 
1886
        :param records: A list to collect the seen records.
 
1887
        :return: A generator of the records in stream.
 
1888
        """
 
1889
        # We make assertions during copying to catch things early for
 
1890
        # easier debugging.
 
1891
        for record, ref_record in izip(stream, expected):
 
1892
            records.append(record)
 
1893
            self.assertEqual(ref_record.key, record.key)
 
1894
            self.assertEqual(ref_record.storage_kind, record.storage_kind)
 
1895
            self.assertEqual(ref_record.parents, record.parents)
 
1896
            yield record
 
1897
 
 
1898
    def stream_to_bytes_or_skip_counter(self, skipped_records, full_texts,
 
1899
        stream):
 
1900
        """Convert a stream to a bytes iterator.
 
1901
 
 
1902
        :param skipped_records: A list with one element to increment when a
 
1903
            record is skipped.
 
1904
        :param full_texts: A dict from key->fulltext representation, for
 
1905
            checking chunked or fulltext stored records.
 
1906
        :param stream: A record_stream.
 
1907
        :return: An iterator over the bytes of each record.
 
1908
        """
 
1909
        for record in stream:
 
1910
            if record.storage_kind in ('chunked', 'fulltext'):
 
1911
                skipped_records[0] += 1
 
1912
                # check the content is correct for direct use.
 
1913
                self.assertRecordHasContent(record, full_texts[record.key])
 
1914
            else:
 
1915
                yield record.get_bytes_as(record.storage_kind)
 
1916
 
 
1917
    def test_get_record_stream_native_formats_are_wire_ready_ft_delta(self):
 
1918
        files = self.get_versionedfiles()
 
1919
        target_files = self.get_versionedfiles('target')
 
1920
        key = self.get_simple_key('ft')
 
1921
        key_delta = self.get_simple_key('delta')
 
1922
        files.add_lines(key, (), ['my text\n', 'content'])
 
1923
        if self.graph:
 
1924
            delta_parents = (key,)
 
1925
        else:
 
1926
            delta_parents = ()
 
1927
        files.add_lines(key_delta, delta_parents, ['different\n', 'content\n'])
 
1928
        local = files.get_record_stream([key, key_delta], 'unordered', False)
 
1929
        ref = files.get_record_stream([key, key_delta], 'unordered', False)
 
1930
        skipped_records = [0]
 
1931
        full_texts = {
 
1932
            key: "my text\ncontent",
 
1933
            key_delta: "different\ncontent\n",
 
1934
            }
 
1935
        byte_stream = self.stream_to_bytes_or_skip_counter(
 
1936
            skipped_records, full_texts, local)
 
1937
        network_stream = versionedfile.NetworkRecordStream(byte_stream).read()
 
1938
        records = []
 
1939
        # insert the stream from the network into a versioned files object so we can
 
1940
        # check the content was carried across correctly without doing delta
 
1941
        # inspection.
 
1942
        target_files.insert_record_stream(
 
1943
            self.assertStreamMetaEqual(records, ref, network_stream))
 
1944
        # No duplicates on the wire thank you!
 
1945
        self.assertEqual(2, len(records) + skipped_records[0])
 
1946
        if len(records):
 
1947
            # if any content was copied it all must have all been.
 
1948
            self.assertIdenticalVersionedFile(files, target_files)
 
1949
 
 
1950
    def test_get_record_stream_native_formats_are_wire_ready_delta(self):
 
1951
        # copy a delta over the wire
 
1952
        files = self.get_versionedfiles()
 
1953
        target_files = self.get_versionedfiles('target')
 
1954
        key = self.get_simple_key('ft')
 
1955
        key_delta = self.get_simple_key('delta')
 
1956
        files.add_lines(key, (), ['my text\n', 'content'])
 
1957
        if self.graph:
 
1958
            delta_parents = (key,)
 
1959
        else:
 
1960
            delta_parents = ()
 
1961
        files.add_lines(key_delta, delta_parents, ['different\n', 'content\n'])
 
1962
        # Copy the basis text across so we can reconstruct the delta during
 
1963
        # insertion into target.
 
1964
        target_files.insert_record_stream(files.get_record_stream([key],
 
1965
            'unordered', False))
 
1966
        local = files.get_record_stream([key_delta], 'unordered', False)
 
1967
        ref = files.get_record_stream([key_delta], 'unordered', False)
 
1968
        skipped_records = [0]
 
1969
        full_texts = {
 
1970
            key_delta: "different\ncontent\n",
 
1971
            }
 
1972
        byte_stream = self.stream_to_bytes_or_skip_counter(
 
1973
            skipped_records, full_texts, local)
 
1974
        network_stream = versionedfile.NetworkRecordStream(byte_stream).read()
 
1975
        records = []
 
1976
        # insert the stream from the network into a versioned files object so we can
 
1977
        # check the content was carried across correctly without doing delta
 
1978
        # inspection during check_stream.
 
1979
        target_files.insert_record_stream(
 
1980
            self.assertStreamMetaEqual(records, ref, network_stream))
 
1981
        # No duplicates on the wire thank you!
 
1982
        self.assertEqual(1, len(records) + skipped_records[0])
 
1983
        if len(records):
 
1984
            # if any content was copied it all must have all been
 
1985
            self.assertIdenticalVersionedFile(files, target_files)
 
1986
 
 
1987
    def test_get_record_stream_wire_ready_delta_closure_included(self):
 
1988
        # copy a delta over the wire with the ability to get its full text.
 
1989
        files = self.get_versionedfiles()
 
1990
        key = self.get_simple_key('ft')
 
1991
        key_delta = self.get_simple_key('delta')
 
1992
        files.add_lines(key, (), ['my text\n', 'content'])
 
1993
        if self.graph:
 
1994
            delta_parents = (key,)
 
1995
        else:
 
1996
            delta_parents = ()
 
1997
        files.add_lines(key_delta, delta_parents, ['different\n', 'content\n'])
 
1998
        local = files.get_record_stream([key_delta], 'unordered', True)
 
1999
        ref = files.get_record_stream([key_delta], 'unordered', True)
 
2000
        skipped_records = [0]
 
2001
        full_texts = {
 
2002
            key_delta: "different\ncontent\n",
 
2003
            }
 
2004
        byte_stream = self.stream_to_bytes_or_skip_counter(
 
2005
            skipped_records, full_texts, local)
 
2006
        network_stream = versionedfile.NetworkRecordStream(byte_stream).read()
 
2007
        records = []
 
2008
        # insert the stream from the network into a versioned files object so we can
 
2009
        # check the content was carried across correctly without doing delta
 
2010
        # inspection during check_stream.
 
2011
        for record in self.assertStreamMetaEqual(records, ref, network_stream):
 
2012
            # we have to be able to get the full text out:
 
2013
            self.assertRecordHasContent(record, full_texts[record.key])
 
2014
        # No duplicates on the wire thank you!
 
2015
        self.assertEqual(1, len(records) + skipped_records[0])
 
2016
 
 
2017
    def assertAbsentRecord(self, files, keys, parents, entries):
 
2018
        """Helper for test_get_record_stream_missing_records_are_absent."""
 
2019
        seen = set()
 
2020
        for factory in entries:
 
2021
            seen.add(factory.key)
 
2022
            if factory.key[-1] == 'absent':
 
2023
                self.assertEqual('absent', factory.storage_kind)
 
2024
                self.assertEqual(None, factory.sha1)
 
2025
                self.assertEqual(None, factory.parents)
 
2026
            else:
 
2027
                self.assertValidStorageKind(factory.storage_kind)
 
2028
                if factory.sha1 is not None:
 
2029
                    sha1 = files.get_sha1s([factory.key])[factory.key]
 
2030
                    self.assertEqual(sha1, factory.sha1)
 
2031
                self.assertEqual(parents[factory.key], factory.parents)
 
2032
                self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
 
2033
                    str)
 
2034
        self.assertEqual(set(keys), seen)
 
2035
 
 
2036
    def test_filter_absent_records(self):
 
2037
        """Requested missing records can be filter trivially."""
 
2038
        files = self.get_versionedfiles()
 
2039
        self.get_diamond_files(files)
 
2040
        keys, _ = self.get_keys_and_sort_order()
 
2041
        parent_map = files.get_parent_map(keys)
 
2042
        # Add an absent record in the middle of the present keys. (We don't ask
 
2043
        # for just absent keys to ensure that content before and after the
 
2044
        # absent keys is still delivered).
 
2045
        present_keys = list(keys)
 
2046
        if self.key_length == 1:
 
2047
            keys.insert(2, ('extra',))
 
2048
        else:
 
2049
            keys.insert(2, ('extra', 'extra'))
 
2050
        entries = files.get_record_stream(keys, 'unordered', False)
 
2051
        seen = set()
 
2052
        self.capture_stream(files, versionedfile.filter_absent(entries), seen.add,
 
2053
            parent_map)
 
2054
        self.assertEqual(set(present_keys), seen)
 
2055
 
 
2056
    def get_mapper(self):
 
2057
        """Get a mapper suitable for the key length of the test interface."""
 
2058
        if self.key_length == 1:
 
2059
            return ConstantMapper('source')
 
2060
        else:
 
2061
            return HashEscapedPrefixMapper()
 
2062
 
 
2063
    def get_parents(self, parents):
 
2064
        """Get parents, taking self.graph into consideration."""
 
2065
        if self.graph:
 
2066
            return parents
 
2067
        else:
 
2068
            return None
 
2069
 
 
2070
    def test_get_parent_map(self):
 
2071
        files = self.get_versionedfiles()
 
2072
        if self.key_length == 1:
 
2073
            parent_details = [
 
2074
                (('r0',), self.get_parents(())),
 
2075
                (('r1',), self.get_parents((('r0',),))),
 
2076
                (('r2',), self.get_parents(())),
 
2077
                (('r3',), self.get_parents(())),
 
2078
                (('m',), self.get_parents((('r0',),('r1',),('r2',),('r3',)))),
 
2079
                ]
 
2080
        else:
 
2081
            parent_details = [
 
2082
                (('FileA', 'r0'), self.get_parents(())),
 
2083
                (('FileA', 'r1'), self.get_parents((('FileA', 'r0'),))),
 
2084
                (('FileA', 'r2'), self.get_parents(())),
 
2085
                (('FileA', 'r3'), self.get_parents(())),
 
2086
                (('FileA', 'm'), self.get_parents((('FileA', 'r0'),
 
2087
                    ('FileA', 'r1'), ('FileA', 'r2'), ('FileA', 'r3')))),
 
2088
                ]
 
2089
        for key, parents in parent_details:
 
2090
            files.add_lines(key, parents, [])
 
2091
            # immediately after adding it should be queryable.
 
2092
            self.assertEqual({key:parents}, files.get_parent_map([key]))
 
2093
        # We can ask for an empty set
 
2094
        self.assertEqual({}, files.get_parent_map([]))
 
2095
        # We can ask for many keys
 
2096
        all_parents = dict(parent_details)
 
2097
        self.assertEqual(all_parents, files.get_parent_map(all_parents.keys()))
 
2098
        # Absent keys are just not included in the result.
 
2099
        keys = all_parents.keys()
 
2100
        if self.key_length == 1:
 
2101
            keys.insert(1, ('missing',))
 
2102
        else:
 
2103
            keys.insert(1, ('missing', 'missing'))
 
2104
        # Absent keys are just ignored
 
2105
        self.assertEqual(all_parents, files.get_parent_map(keys))
 
2106
 
 
2107
    def test_get_sha1s(self):
 
2108
        files = self.get_versionedfiles()
 
2109
        self.get_diamond_files(files)
 
2110
        if self.key_length == 1:
 
2111
            keys = [('base',), ('origin',), ('left',), ('merged',), ('right',)]
 
2112
        else:
 
2113
            # ask for shas from different prefixes.
 
2114
            keys = [
 
2115
                ('FileA', 'base'), ('FileB', 'origin'), ('FileA', 'left'),
 
2116
                ('FileA', 'merged'), ('FileB', 'right'),
 
2117
                ]
 
2118
        self.assertEqual({
 
2119
            keys[0]: '51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44',
 
2120
            keys[1]: '00e364d235126be43292ab09cb4686cf703ddc17',
 
2121
            keys[2]: 'a8478686da38e370e32e42e8a0c220e33ee9132f',
 
2122
            keys[3]: 'ed8bce375198ea62444dc71952b22cfc2b09226d',
 
2123
            keys[4]: '9ef09dfa9d86780bdec9219a22560c6ece8e0ef1',
 
2124
            },
 
2125
            files.get_sha1s(keys))
 
2126
 
 
2127
    def test_insert_record_stream_empty(self):
 
2128
        """Inserting an empty record stream should work."""
 
2129
        files = self.get_versionedfiles()
 
2130
        files.insert_record_stream([])
 
2131
 
 
2132
    def assertIdenticalVersionedFile(self, expected, actual):
 
2133
        """Assert that left and right have the same contents."""
 
2134
        self.assertEqual(set(actual.keys()), set(expected.keys()))
 
2135
        actual_parents = actual.get_parent_map(actual.keys())
 
2136
        if self.graph:
 
2137
            self.assertEqual(actual_parents, expected.get_parent_map(expected.keys()))
 
2138
        else:
 
2139
            for key, parents in actual_parents.items():
 
2140
                self.assertEqual(None, parents)
 
2141
        for key in actual.keys():
 
2142
            actual_text = actual.get_record_stream(
 
2143
                [key], 'unordered', True).next().get_bytes_as('fulltext')
 
2144
            expected_text = expected.get_record_stream(
 
2145
                [key], 'unordered', True).next().get_bytes_as('fulltext')
 
2146
            self.assertEqual(actual_text, expected_text)
 
2147
 
 
2148
    def test_insert_record_stream_fulltexts(self):
 
2149
        """Any file should accept a stream of fulltexts."""
 
2150
        files = self.get_versionedfiles()
 
2151
        mapper = self.get_mapper()
 
2152
        source_transport = self.get_transport('source')
 
2153
        source_transport.mkdir('.')
 
2154
        # weaves always output fulltexts.
 
2155
        source = make_versioned_files_factory(WeaveFile, mapper)(
 
2156
            source_transport)
 
2157
        self.get_diamond_files(source, trailing_eol=False)
 
2158
        stream = source.get_record_stream(source.keys(), 'topological',
 
2159
            False)
 
2160
        files.insert_record_stream(stream)
 
2161
        self.assertIdenticalVersionedFile(source, files)
 
2162
 
 
2163
    def test_insert_record_stream_fulltexts_noeol(self):
 
2164
        """Any file should accept a stream of fulltexts."""
 
2165
        files = self.get_versionedfiles()
 
2166
        mapper = self.get_mapper()
 
2167
        source_transport = self.get_transport('source')
 
2168
        source_transport.mkdir('.')
 
2169
        # weaves always output fulltexts.
 
2170
        source = make_versioned_files_factory(WeaveFile, mapper)(
 
2171
            source_transport)
 
2172
        self.get_diamond_files(source, trailing_eol=False)
 
2173
        stream = source.get_record_stream(source.keys(), 'topological',
 
2174
            False)
 
2175
        files.insert_record_stream(stream)
 
2176
        self.assertIdenticalVersionedFile(source, files)
 
2177
 
 
2178
    def test_insert_record_stream_annotated_knits(self):
 
2179
        """Any file should accept a stream from plain knits."""
 
2180
        files = self.get_versionedfiles()
 
2181
        mapper = self.get_mapper()
 
2182
        source_transport = self.get_transport('source')
 
2183
        source_transport.mkdir('.')
 
2184
        source = make_file_factory(True, mapper)(source_transport)
 
2185
        self.get_diamond_files(source)
 
2186
        stream = source.get_record_stream(source.keys(), 'topological',
 
2187
            False)
 
2188
        files.insert_record_stream(stream)
 
2189
        self.assertIdenticalVersionedFile(source, files)
 
2190
 
 
2191
    def test_insert_record_stream_annotated_knits_noeol(self):
 
2192
        """Any file should accept a stream from plain knits."""
 
2193
        files = self.get_versionedfiles()
 
2194
        mapper = self.get_mapper()
 
2195
        source_transport = self.get_transport('source')
 
2196
        source_transport.mkdir('.')
 
2197
        source = make_file_factory(True, mapper)(source_transport)
 
2198
        self.get_diamond_files(source, trailing_eol=False)
 
2199
        stream = source.get_record_stream(source.keys(), 'topological',
 
2200
            False)
 
2201
        files.insert_record_stream(stream)
 
2202
        self.assertIdenticalVersionedFile(source, files)
 
2203
 
 
2204
    def test_insert_record_stream_plain_knits(self):
 
2205
        """Any file should accept a stream from plain knits."""
 
2206
        files = self.get_versionedfiles()
 
2207
        mapper = self.get_mapper()
 
2208
        source_transport = self.get_transport('source')
 
2209
        source_transport.mkdir('.')
 
2210
        source = make_file_factory(False, mapper)(source_transport)
 
2211
        self.get_diamond_files(source)
 
2212
        stream = source.get_record_stream(source.keys(), 'topological',
 
2213
            False)
 
2214
        files.insert_record_stream(stream)
 
2215
        self.assertIdenticalVersionedFile(source, files)
 
2216
 
 
2217
    def test_insert_record_stream_plain_knits_noeol(self):
 
2218
        """Any file should accept a stream from plain knits."""
 
2219
        files = self.get_versionedfiles()
 
2220
        mapper = self.get_mapper()
 
2221
        source_transport = self.get_transport('source')
 
2222
        source_transport.mkdir('.')
 
2223
        source = make_file_factory(False, mapper)(source_transport)
 
2224
        self.get_diamond_files(source, trailing_eol=False)
 
2225
        stream = source.get_record_stream(source.keys(), 'topological',
 
2226
            False)
 
2227
        files.insert_record_stream(stream)
 
2228
        self.assertIdenticalVersionedFile(source, files)
 
2229
 
 
2230
    def test_insert_record_stream_existing_keys(self):
 
2231
        """Inserting keys already in a file should not error."""
 
2232
        files = self.get_versionedfiles()
 
2233
        source = self.get_versionedfiles('source')
 
2234
        self.get_diamond_files(source)
 
2235
        # insert some keys into f.
 
2236
        self.get_diamond_files(files, left_only=True)
 
2237
        stream = source.get_record_stream(source.keys(), 'topological',
 
2238
            False)
 
2239
        files.insert_record_stream(stream)
 
2240
        self.assertIdenticalVersionedFile(source, files)
 
2241
 
 
2242
    def test_insert_record_stream_missing_keys(self):
 
2243
        """Inserting a stream with absent keys should raise an error."""
 
2244
        files = self.get_versionedfiles()
 
2245
        source = self.get_versionedfiles('source')
 
2246
        stream = source.get_record_stream([('missing',) * self.key_length],
 
2247
            'topological', False)
 
2248
        self.assertRaises(errors.RevisionNotPresent, files.insert_record_stream,
 
2249
            stream)
 
2250
 
 
2251
    def test_insert_record_stream_out_of_order(self):
 
2252
        """An out of order stream can either error or work."""
 
2253
        files = self.get_versionedfiles()
 
2254
        source = self.get_versionedfiles('source')
 
2255
        self.get_diamond_files(source)
 
2256
        if self.key_length == 1:
 
2257
            origin_keys = [('origin',)]
 
2258
            end_keys = [('merged',), ('left',)]
 
2259
            start_keys = [('right',), ('base',)]
 
2260
        else:
 
2261
            origin_keys = [('FileA', 'origin'), ('FileB', 'origin')]
 
2262
            end_keys = [('FileA', 'merged',), ('FileA', 'left',),
 
2263
                ('FileB', 'merged',), ('FileB', 'left',)]
 
2264
            start_keys = [('FileA', 'right',), ('FileA', 'base',),
 
2265
                ('FileB', 'right',), ('FileB', 'base',)]
 
2266
        origin_entries = source.get_record_stream(origin_keys, 'unordered', False)
 
2267
        end_entries = source.get_record_stream(end_keys, 'topological', False)
 
2268
        start_entries = source.get_record_stream(start_keys, 'topological', False)
 
2269
        entries = chain(origin_entries, end_entries, start_entries)
 
2270
        try:
 
2271
            files.insert_record_stream(entries)
 
2272
        except RevisionNotPresent:
 
2273
            # Must not have corrupted the file.
 
2274
            files.check()
 
2275
        else:
 
2276
            self.assertIdenticalVersionedFile(source, files)
 
2277
 
 
2278
    def get_knit_delta_source(self):
 
2279
        """Get a source that can produce a stream with knit delta records,
 
2280
        regardless of this test's scenario.
 
2281
        """
 
2282
        mapper = self.get_mapper()
 
2283
        source_transport = self.get_transport('source')
 
2284
        source_transport.mkdir('.')
 
2285
        source = make_file_factory(False, mapper)(source_transport)
 
2286
        get_diamond_files(source, self.key_length, trailing_eol=True,
 
2287
            nograph=False, left_only=False)
 
2288
        return source
 
2289
 
 
2290
    def test_insert_record_stream_delta_missing_basis_no_corruption(self):
 
2291
        """Insertion where a needed basis is not included notifies the caller
 
2292
        of the missing basis.  In the meantime a record missing its basis is
 
2293
        not added.
 
2294
        """
 
2295
        source = self.get_knit_delta_source()
 
2296
        keys = [self.get_simple_key('origin'), self.get_simple_key('merged')]
 
2297
        entries = source.get_record_stream(keys, 'unordered', False)
 
2298
        files = self.get_versionedfiles()
 
2299
        if self.support_partial_insertion:
 
2300
            self.assertEqual([],
 
2301
                list(files.get_missing_compression_parent_keys()))
 
2302
            files.insert_record_stream(entries)
 
2303
            missing_bases = files.get_missing_compression_parent_keys()
 
2304
            self.assertEqual(set([self.get_simple_key('left')]),
 
2305
                set(missing_bases))
 
2306
            self.assertEqual(set(keys), set(files.get_parent_map(keys)))
 
2307
        else:
 
2308
            self.assertRaises(
 
2309
                errors.RevisionNotPresent, files.insert_record_stream, entries)
 
2310
            files.check()
 
2311
 
 
2312
    def test_insert_record_stream_delta_missing_basis_can_be_added_later(self):
 
2313
        """Insertion where a needed basis is not included notifies the caller
 
2314
        of the missing basis.  That basis can be added in a second
 
2315
        insert_record_stream call that does not need to repeat records present
 
2316
        in the previous stream.  The record(s) that required that basis are
 
2317
        fully inserted once their basis is no longer missing.
 
2318
        """
 
2319
        if not self.support_partial_insertion:
 
2320
            raise TestNotApplicable(
 
2321
                'versioned file scenario does not support partial insertion')
 
2322
        source = self.get_knit_delta_source()
 
2323
        entries = source.get_record_stream([self.get_simple_key('origin'),
 
2324
            self.get_simple_key('merged')], 'unordered', False)
 
2325
        files = self.get_versionedfiles()
 
2326
        files.insert_record_stream(entries)
 
2327
        missing_bases = files.get_missing_compression_parent_keys()
 
2328
        self.assertEqual(set([self.get_simple_key('left')]),
 
2329
            set(missing_bases))
 
2330
        # 'merged' is inserted (although a commit of a write group involving
 
2331
        # this versionedfiles would fail).
 
2332
        merged_key = self.get_simple_key('merged')
 
2333
        self.assertEqual(
 
2334
            [merged_key], files.get_parent_map([merged_key]).keys())
 
2335
        # Add the full delta closure of the missing records
 
2336
        missing_entries = source.get_record_stream(
 
2337
            missing_bases, 'unordered', True)
 
2338
        files.insert_record_stream(missing_entries)
 
2339
        # Now 'merged' is fully inserted (and a commit would succeed).
 
2340
        self.assertEqual([], list(files.get_missing_compression_parent_keys()))
 
2341
        self.assertEqual(
 
2342
            [merged_key], files.get_parent_map([merged_key]).keys())
 
2343
        files.check()
 
2344
 
 
2345
    def test_iter_lines_added_or_present_in_keys(self):
 
2346
        # test that we get at least an equalset of the lines added by
 
2347
        # versions in the store.
 
2348
        # the ordering here is to make a tree so that dumb searches have
 
2349
        # more changes to muck up.
 
2350
 
 
2351
        class InstrumentedProgress(progress.DummyProgress):
 
2352
 
 
2353
            def __init__(self):
 
2354
 
 
2355
                progress.DummyProgress.__init__(self)
 
2356
                self.updates = []
 
2357
 
 
2358
            def update(self, msg=None, current=None, total=None):
 
2359
                self.updates.append((msg, current, total))
 
2360
 
 
2361
        files = self.get_versionedfiles()
 
2362
        # add a base to get included
 
2363
        files.add_lines(self.get_simple_key('base'), (), ['base\n'])
 
2364
        # add a ancestor to be included on one side
 
2365
        files.add_lines(self.get_simple_key('lancestor'), (), ['lancestor\n'])
 
2366
        # add a ancestor to be included on the other side
 
2367
        files.add_lines(self.get_simple_key('rancestor'),
 
2368
            self.get_parents([self.get_simple_key('base')]), ['rancestor\n'])
 
2369
        # add a child of rancestor with no eofile-nl
 
2370
        files.add_lines(self.get_simple_key('child'),
 
2371
            self.get_parents([self.get_simple_key('rancestor')]),
 
2372
            ['base\n', 'child\n'])
 
2373
        # add a child of lancestor and base to join the two roots
 
2374
        files.add_lines(self.get_simple_key('otherchild'),
 
2375
            self.get_parents([self.get_simple_key('lancestor'),
 
2376
                self.get_simple_key('base')]),
 
2377
            ['base\n', 'lancestor\n', 'otherchild\n'])
 
2378
        def iter_with_keys(keys, expected):
 
2379
            # now we need to see what lines are returned, and how often.
 
2380
            lines = {}
 
2381
            progress = InstrumentedProgress()
 
2382
            # iterate over the lines
 
2383
            for line in files.iter_lines_added_or_present_in_keys(keys,
 
2384
                pb=progress):
 
2385
                lines.setdefault(line, 0)
 
2386
                lines[line] += 1
 
2387
            if []!= progress.updates:
 
2388
                self.assertEqual(expected, progress.updates)
 
2389
            return lines
 
2390
        lines = iter_with_keys(
 
2391
            [self.get_simple_key('child'), self.get_simple_key('otherchild')],
 
2392
            [('Walking content', 0, 2),
 
2393
             ('Walking content', 1, 2),
 
2394
             ('Walking content', 2, 2)])
 
2395
        # we must see child and otherchild
 
2396
        self.assertTrue(lines[('child\n', self.get_simple_key('child'))] > 0)
 
2397
        self.assertTrue(
 
2398
            lines[('otherchild\n', self.get_simple_key('otherchild'))] > 0)
 
2399
        # we dont care if we got more than that.
 
2400
 
 
2401
        # test all lines
 
2402
        lines = iter_with_keys(files.keys(),
 
2403
            [('Walking content', 0, 5),
 
2404
             ('Walking content', 1, 5),
 
2405
             ('Walking content', 2, 5),
 
2406
             ('Walking content', 3, 5),
 
2407
             ('Walking content', 4, 5),
 
2408
             ('Walking content', 5, 5)])
 
2409
        # all lines must be seen at least once
 
2410
        self.assertTrue(lines[('base\n', self.get_simple_key('base'))] > 0)
 
2411
        self.assertTrue(
 
2412
            lines[('lancestor\n', self.get_simple_key('lancestor'))] > 0)
 
2413
        self.assertTrue(
 
2414
            lines[('rancestor\n', self.get_simple_key('rancestor'))] > 0)
 
2415
        self.assertTrue(lines[('child\n', self.get_simple_key('child'))] > 0)
 
2416
        self.assertTrue(
 
2417
            lines[('otherchild\n', self.get_simple_key('otherchild'))] > 0)
 
2418
 
 
2419
    def test_make_mpdiffs(self):
 
2420
        from bzrlib import multiparent
 
2421
        files = self.get_versionedfiles('source')
 
2422
        # add texts that should trip the knit maximum delta chain threshold
 
2423
        # as well as doing parallel chains of data in knits.
 
2424
        # this is done by two chains of 25 insertions
 
2425
        files.add_lines(self.get_simple_key('base'), [], ['line\n'])
 
2426
        files.add_lines(self.get_simple_key('noeol'),
 
2427
            self.get_parents([self.get_simple_key('base')]), ['line'])
 
2428
        # detailed eol tests:
 
2429
        # shared last line with parent no-eol
 
2430
        files.add_lines(self.get_simple_key('noeolsecond'),
 
2431
            self.get_parents([self.get_simple_key('noeol')]),
 
2432
                ['line\n', 'line'])
 
2433
        # differing last line with parent, both no-eol
 
2434
        files.add_lines(self.get_simple_key('noeolnotshared'),
 
2435
            self.get_parents([self.get_simple_key('noeolsecond')]),
 
2436
                ['line\n', 'phone'])
 
2437
        # add eol following a noneol parent, change content
 
2438
        files.add_lines(self.get_simple_key('eol'),
 
2439
            self.get_parents([self.get_simple_key('noeol')]), ['phone\n'])
 
2440
        # add eol following a noneol parent, no change content
 
2441
        files.add_lines(self.get_simple_key('eolline'),
 
2442
            self.get_parents([self.get_simple_key('noeol')]), ['line\n'])
 
2443
        # noeol with no parents:
 
2444
        files.add_lines(self.get_simple_key('noeolbase'), [], ['line'])
 
2445
        # noeol preceeding its leftmost parent in the output:
 
2446
        # this is done by making it a merge of two parents with no common
 
2447
        # anestry: noeolbase and noeol with the
 
2448
        # later-inserted parent the leftmost.
 
2449
        files.add_lines(self.get_simple_key('eolbeforefirstparent'),
 
2450
            self.get_parents([self.get_simple_key('noeolbase'),
 
2451
                self.get_simple_key('noeol')]),
 
2452
            ['line'])
 
2453
        # two identical eol texts
 
2454
        files.add_lines(self.get_simple_key('noeoldup'),
 
2455
            self.get_parents([self.get_simple_key('noeol')]), ['line'])
 
2456
        next_parent = self.get_simple_key('base')
 
2457
        text_name = 'chain1-'
 
2458
        text = ['line\n']
 
2459
        sha1s = {0 :'da6d3141cb4a5e6f464bf6e0518042ddc7bfd079',
 
2460
                 1 :'45e21ea146a81ea44a821737acdb4f9791c8abe7',
 
2461
                 2 :'e1f11570edf3e2a070052366c582837a4fe4e9fa',
 
2462
                 3 :'26b4b8626da827088c514b8f9bbe4ebf181edda1',
 
2463
                 4 :'e28a5510be25ba84d31121cff00956f9970ae6f6',
 
2464
                 5 :'d63ec0ce22e11dcf65a931b69255d3ac747a318d',
 
2465
                 6 :'2c2888d288cb5e1d98009d822fedfe6019c6a4ea',
 
2466
                 7 :'95c14da9cafbf828e3e74a6f016d87926ba234ab',
 
2467
                 8 :'779e9a0b28f9f832528d4b21e17e168c67697272',
 
2468
                 9 :'1f8ff4e5c6ff78ac106fcfe6b1e8cb8740ff9a8f',
 
2469
                 10:'131a2ae712cf51ed62f143e3fbac3d4206c25a05',
 
2470
                 11:'c5a9d6f520d2515e1ec401a8f8a67e6c3c89f199',
 
2471
                 12:'31a2286267f24d8bedaa43355f8ad7129509ea85',
 
2472
                 13:'dc2a7fe80e8ec5cae920973973a8ee28b2da5e0a',
 
2473
                 14:'2c4b1736566b8ca6051e668de68650686a3922f2',
 
2474
                 15:'5912e4ecd9b0c07be4d013e7e2bdcf9323276cde',
 
2475
                 16:'b0d2e18d3559a00580f6b49804c23fea500feab3',
 
2476
                 17:'8e1d43ad72f7562d7cb8f57ee584e20eb1a69fc7',
 
2477
                 18:'5cf64a3459ae28efa60239e44b20312d25b253f3',
 
2478
                 19:'1ebed371807ba5935958ad0884595126e8c4e823',
 
2479
                 20:'2aa62a8b06fb3b3b892a3292a068ade69d5ee0d3',
 
2480
                 21:'01edc447978004f6e4e962b417a4ae1955b6fe5d',
 
2481
                 22:'d8d8dc49c4bf0bab401e0298bb5ad827768618bb',
 
2482
                 23:'c21f62b1c482862983a8ffb2b0c64b3451876e3f',
 
2483
                 24:'c0593fe795e00dff6b3c0fe857a074364d5f04fc',
 
2484
                 25:'dd1a1cf2ba9cc225c3aff729953e6364bf1d1855',
 
2485
                 }
 
2486
        for depth in range(26):
 
2487
            new_version = self.get_simple_key(text_name + '%s' % depth)
 
2488
            text = text + ['line\n']
 
2489
            files.add_lines(new_version, self.get_parents([next_parent]), text)
 
2490
            next_parent = new_version
 
2491
        next_parent = self.get_simple_key('base')
 
2492
        text_name = 'chain2-'
 
2493
        text = ['line\n']
 
2494
        for depth in range(26):
 
2495
            new_version = self.get_simple_key(text_name + '%s' % depth)
 
2496
            text = text + ['line\n']
 
2497
            files.add_lines(new_version, self.get_parents([next_parent]), text)
 
2498
            next_parent = new_version
 
2499
        target = self.get_versionedfiles('target')
 
2500
        for key in multiparent.topo_iter_keys(files, files.keys()):
 
2501
            mpdiff = files.make_mpdiffs([key])[0]
 
2502
            parents = files.get_parent_map([key])[key] or []
 
2503
            target.add_mpdiffs(
 
2504
                [(key, parents, files.get_sha1s([key])[key], mpdiff)])
 
2505
            self.assertEqualDiff(
 
2506
                files.get_record_stream([key], 'unordered',
 
2507
                    True).next().get_bytes_as('fulltext'),
 
2508
                target.get_record_stream([key], 'unordered',
 
2509
                    True).next().get_bytes_as('fulltext')
 
2510
                )
 
2511
 
 
2512
    def test_keys(self):
 
2513
        # While use is discouraged, versions() is still needed by aspects of
 
2514
        # bzr.
 
2515
        files = self.get_versionedfiles()
 
2516
        self.assertEqual(set(), set(files.keys()))
 
2517
        if self.key_length == 1:
 
2518
            key = ('foo',)
 
2519
        else:
 
2520
            key = ('foo', 'bar',)
 
2521
        files.add_lines(key, (), [])
 
2522
        self.assertEqual(set([key]), set(files.keys()))
 
2523
 
 
2524
 
 
2525
class VirtualVersionedFilesTests(TestCase):
 
2526
    """Basic tests for the VirtualVersionedFiles implementations."""
 
2527
 
 
2528
    def _get_parent_map(self, keys):
 
2529
        ret = {}
 
2530
        for k in keys:
 
2531
            if k in self._parent_map:
 
2532
                ret[k] = self._parent_map[k]
 
2533
        return ret
 
2534
 
 
2535
    def setUp(self):
 
2536
        TestCase.setUp(self)
 
2537
        self._lines = {}
 
2538
        self._parent_map = {}
 
2539
        self.texts = VirtualVersionedFiles(self._get_parent_map,
 
2540
                                           self._lines.get)
 
2541
 
 
2542
    def test_add_lines(self):
 
2543
        self.assertRaises(NotImplementedError,
 
2544
                self.texts.add_lines, "foo", [], [])
 
2545
 
 
2546
    def test_add_mpdiffs(self):
 
2547
        self.assertRaises(NotImplementedError,
 
2548
                self.texts.add_mpdiffs, [])
 
2549
 
 
2550
    def test_check(self):
 
2551
        self.assertTrue(self.texts.check())
 
2552
 
 
2553
    def test_insert_record_stream(self):
 
2554
        self.assertRaises(NotImplementedError, self.texts.insert_record_stream,
 
2555
                          [])
 
2556
 
 
2557
    def test_get_sha1s_nonexistent(self):
 
2558
        self.assertEquals({}, self.texts.get_sha1s([("NONEXISTENT",)]))
 
2559
 
 
2560
    def test_get_sha1s(self):
 
2561
        self._lines["key"] = ["dataline1", "dataline2"]
 
2562
        self.assertEquals({("key",): osutils.sha_strings(self._lines["key"])},
 
2563
                           self.texts.get_sha1s([("key",)]))
 
2564
 
 
2565
    def test_get_parent_map(self):
 
2566
        self._parent_map = {"G": ("A", "B")}
 
2567
        self.assertEquals({("G",): (("A",),("B",))},
 
2568
                          self.texts.get_parent_map([("G",), ("L",)]))
 
2569
 
 
2570
    def test_get_record_stream(self):
 
2571
        self._lines["A"] = ["FOO", "BAR"]
 
2572
        it = self.texts.get_record_stream([("A",)], "unordered", True)
 
2573
        record = it.next()
 
2574
        self.assertEquals("chunked", record.storage_kind)
 
2575
        self.assertEquals("FOOBAR", record.get_bytes_as("fulltext"))
 
2576
        self.assertEquals(["FOO", "BAR"], record.get_bytes_as("chunked"))
 
2577
 
 
2578
    def test_get_record_stream_absent(self):
 
2579
        it = self.texts.get_record_stream([("A",)], "unordered", True)
 
2580
        record = it.next()
 
2581
        self.assertEquals("absent", record.storage_kind)
 
2582
 
 
2583
    def test_iter_lines_added_or_present_in_keys(self):
 
2584
        self._lines["A"] = ["FOO", "BAR"]
 
2585
        self._lines["B"] = ["HEY"]
 
2586
        self._lines["C"] = ["Alberta"]
 
2587
        it = self.texts.iter_lines_added_or_present_in_keys([("A",), ("B",)])
 
2588
        self.assertEquals(sorted([("FOO", "A"), ("BAR", "A"), ("HEY", "B")]),
 
2589
            sorted(list(it)))
 
2590
 
 
2591
 
 
2592
class TestOrderingVersionedFilesDecorator(TestCaseWithMemoryTransport):
 
2593
 
 
2594
    def get_ordering_vf(self, key_priority):
 
2595
        builder = self.make_branch_builder('test')
 
2596
        builder.start_series()
 
2597
        builder.build_snapshot('A', None, [
 
2598
            ('add', ('', 'TREE_ROOT', 'directory', None))])
 
2599
        builder.build_snapshot('B', ['A'], [])
 
2600
        builder.build_snapshot('C', ['B'], [])
 
2601
        builder.build_snapshot('D', ['C'], [])
 
2602
        builder.finish_series()
 
2603
        b = builder.get_branch()
 
2604
        b.lock_read()
 
2605
        self.addCleanup(b.unlock)
 
2606
        vf = b.repository.inventories
 
2607
        return versionedfile.OrderingVersionedFilesDecorator(vf, key_priority)
 
2608
 
 
2609
    def test_get_empty(self):
 
2610
        vf = self.get_ordering_vf({})
 
2611
        self.assertEqual([], vf.calls)
 
2612
 
 
2613
    def test_get_record_stream_topological(self):
 
2614
        vf = self.get_ordering_vf({('A',): 3, ('B',): 2, ('C',): 4, ('D',): 1})
 
2615
        request_keys = [('B',), ('C',), ('D',), ('A',)]
 
2616
        keys = [r.key for r in vf.get_record_stream(request_keys,
 
2617
                                    'topological', False)]
 
2618
        # We should have gotten the keys in topological order
 
2619
        self.assertEqual([('A',), ('B',), ('C',), ('D',)], keys)
 
2620
        # And recorded that the request was made
 
2621
        self.assertEqual([('get_record_stream', request_keys, 'topological',
 
2622
                           False)], vf.calls)
 
2623
 
 
2624
    def test_get_record_stream_ordered(self):
 
2625
        vf = self.get_ordering_vf({('A',): 3, ('B',): 2, ('C',): 4, ('D',): 1})
 
2626
        request_keys = [('B',), ('C',), ('D',), ('A',)]
 
2627
        keys = [r.key for r in vf.get_record_stream(request_keys,
 
2628
                                   'unordered', False)]
 
2629
        # They should be returned based on their priority
 
2630
        self.assertEqual([('D',), ('B',), ('A',), ('C',)], keys)
 
2631
        # And the request recorded
 
2632
        self.assertEqual([('get_record_stream', request_keys, 'unordered',
 
2633
                           False)], vf.calls)
 
2634
 
 
2635
    def test_get_record_stream_implicit_order(self):
 
2636
        vf = self.get_ordering_vf({('B',): 2, ('D',): 1})
 
2637
        request_keys = [('B',), ('C',), ('D',), ('A',)]
 
2638
        keys = [r.key for r in vf.get_record_stream(request_keys,
 
2639
                                   'unordered', False)]
 
2640
        # A and C are not in the map, so they get sorted to the front. A comes
 
2641
        # before C alphabetically, so it comes back first
 
2642
        self.assertEqual([('A',), ('C',), ('D',), ('B',)], keys)
 
2643
        # And the request recorded
 
2644
        self.assertEqual([('get_record_stream', request_keys, 'unordered',
 
2645
                           False)], vf.calls)