~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_versionedfile.py

  • Committer: Martin Pool
  • Date: 2010-01-29 10:36:23 UTC
  • mto: This revision was merged to the branch mainline in revision 4992.
  • Revision ID: mbp@sourcefrog.net-20100129103623-hywka5hymo5z13jw
Change url to canonical.com or wiki, plus some doc improvements in passing

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