~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_versionedfile.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-06-16 14:33:42 UTC
  • mfrom: (1770.2.1 config)
  • Revision ID: pqm@pqm.ubuntu.com-20060616143342-8f7f4a4f77c1e4c8
Use create_signature for signing policy, deprecate check_signatures for this

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005 by Canonical Ltd
2
2
#
3
3
# Authors:
4
4
#   Johan Rydberg <jrydberg@gnu.org>
7
7
# it under the terms of the GNU General Public License as published by
8
8
# the Free Software Foundation; either version 2 of the License, or
9
9
# (at your option) any later version.
10
 
#
 
10
 
11
11
# This program is distributed in the hope that it will be useful,
12
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
13
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
14
# GNU General Public License for more details.
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
18
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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
25
24
from StringIO import StringIO
26
25
 
27
26
import bzrlib
28
 
from bzrlib import (
29
 
    errors,
30
 
    osutils,
31
 
    progress,
32
 
    )
 
27
import bzrlib.errors as errors
33
28
from bzrlib.errors import (
34
 
                           RevisionNotPresent,
 
29
                           RevisionNotPresent, 
35
30
                           RevisionAlreadyPresent,
36
31
                           WeaveParentMismatch
37
32
                           )
38
 
from bzrlib import knit as _mod_knit
39
 
from bzrlib.knit import (
40
 
    cleanup_pack_knit,
41
 
    make_file_factory,
42
 
    make_pack_factory,
43
 
    KnitAnnotateFactory,
44
 
    KnitPlainFactory,
45
 
    )
46
 
from bzrlib.symbol_versioning import one_four, one_five
47
 
from bzrlib.tests import (
48
 
    TestCase,
49
 
    TestCaseWithMemoryTransport,
50
 
    TestScenarioApplier,
51
 
    TestSkipped,
52
 
    condition_isinstance,
53
 
    split_suite_by_condition,
54
 
    iter_suite_tests,
55
 
    )
56
 
from bzrlib.tests.http_utils import TestCaseWithWebserver
 
33
from bzrlib.knit import KnitVersionedFile, \
 
34
     KnitAnnotateFactory
 
35
from bzrlib.tests import TestCaseWithTransport
 
36
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
57
37
from bzrlib.trace import mutter
58
38
from bzrlib.transport import get_transport
59
39
from bzrlib.transport.memory import MemoryTransport
60
40
from bzrlib.tsort import topo_sort
61
 
from bzrlib.tuned_gzip import GzipFile
62
41
import bzrlib.versionedfile as versionedfile
63
 
from bzrlib.versionedfile import (
64
 
    ConstantMapper,
65
 
    HashEscapedPrefixMapper,
66
 
    PrefixMapper,
67
 
    VirtualVersionedFiles,
68
 
    make_versioned_files_factory,
69
 
    )
70
42
from bzrlib.weave import WeaveFile
71
43
from bzrlib.weavefile import read_weave, write_weave
72
44
 
73
45
 
74
 
def load_tests(standard_tests, module, loader):
75
 
    """Parameterize VersionedFiles tests for different implementations."""
76
 
    to_adapt, result = split_suite_by_condition(
77
 
        standard_tests, condition_isinstance(TestVersionedFiles))
78
 
    len_one_adapter = TestScenarioApplier()
79
 
    len_two_adapter = TestScenarioApplier()
80
 
    # We want to be sure of behaviour for:
81
 
    # weaves prefix layout (weave texts)
82
 
    # individually named weaves (weave inventories)
83
 
    # annotated knits - prefix|hash|hash-escape layout, we test the third only
84
 
    #                   as it is the most complex mapper.
85
 
    # individually named knits
86
 
    # individual no-graph knits in packs (signatures)
87
 
    # individual graph knits in packs (inventories)
88
 
    # individual graph nocompression knits in packs (revisions)
89
 
    # plain text knits in packs (texts)
90
 
    len_one_adapter.scenarios = [
91
 
        ('weave-named', {
92
 
            'cleanup':None,
93
 
            'factory':make_versioned_files_factory(WeaveFile,
94
 
                ConstantMapper('inventory')),
95
 
            'graph':True,
96
 
            'key_length':1,
97
 
            }),
98
 
        ('named-knit', {
99
 
            'cleanup':None,
100
 
            'factory':make_file_factory(False, ConstantMapper('revisions')),
101
 
            'graph':True,
102
 
            'key_length':1,
103
 
            }),
104
 
        ('named-nograph-knit-pack', {
105
 
            'cleanup':cleanup_pack_knit,
106
 
            'factory':make_pack_factory(False, False, 1),
107
 
            'graph':False,
108
 
            'key_length':1,
109
 
            }),
110
 
        ('named-graph-knit-pack', {
111
 
            'cleanup':cleanup_pack_knit,
112
 
            'factory':make_pack_factory(True, True, 1),
113
 
            'graph':True,
114
 
            'key_length':1,
115
 
            }),
116
 
        ('named-graph-nodelta-knit-pack', {
117
 
            'cleanup':cleanup_pack_knit,
118
 
            'factory':make_pack_factory(True, False, 1),
119
 
            'graph':True,
120
 
            'key_length':1,
121
 
            }),
122
 
        ]
123
 
    len_two_adapter.scenarios = [
124
 
        ('weave-prefix', {
125
 
            'cleanup':None,
126
 
            'factory':make_versioned_files_factory(WeaveFile,
127
 
                PrefixMapper()),
128
 
            'graph':True,
129
 
            'key_length':2,
130
 
            }),
131
 
        ('annotated-knit-escape', {
132
 
            'cleanup':None,
133
 
            'factory':make_file_factory(True, HashEscapedPrefixMapper()),
134
 
            'graph':True,
135
 
            'key_length':2,
136
 
            }),
137
 
        ('plain-knit-pack', {
138
 
            'cleanup':cleanup_pack_knit,
139
 
            'factory':make_pack_factory(True, True, 2),
140
 
            'graph':True,
141
 
            'key_length':2,
142
 
            }),
143
 
        ]
144
 
    for test in iter_suite_tests(to_adapt):
145
 
        result.addTests(len_one_adapter.adapt(test))
146
 
        result.addTests(len_two_adapter.adapt(test))
147
 
    return result
148
 
 
149
 
 
150
 
def get_diamond_vf(f, trailing_eol=True, left_only=False):
151
 
    """Get a diamond graph to exercise deltas and merges.
152
 
    
153
 
    :param trailing_eol: If True end the last line with \n.
154
 
    """
155
 
    parents = {
156
 
        'origin': (),
157
 
        'base': (('origin',),),
158
 
        'left': (('base',),),
159
 
        'right': (('base',),),
160
 
        'merged': (('left',), ('right',)),
161
 
        }
162
 
    # insert a diamond graph to exercise deltas and merges.
163
 
    if trailing_eol:
164
 
        last_char = '\n'
165
 
    else:
166
 
        last_char = ''
167
 
    f.add_lines('origin', [], ['origin' + last_char])
168
 
    f.add_lines('base', ['origin'], ['base' + last_char])
169
 
    f.add_lines('left', ['base'], ['base\n', 'left' + last_char])
170
 
    if not left_only:
171
 
        f.add_lines('right', ['base'],
172
 
            ['base\n', 'right' + last_char])
173
 
        f.add_lines('merged', ['left', 'right'],
174
 
            ['base\n', 'left\n', 'right\n', 'merged' + last_char])
175
 
    return f, parents
176
 
 
177
 
 
178
 
def get_diamond_files(files, key_length, trailing_eol=True, left_only=False,
179
 
    nograph=False):
180
 
    """Get a diamond graph to exercise deltas and merges.
181
 
 
182
 
    This creates a 5-node graph in files. If files supports 2-length keys two
183
 
    graphs are made to exercise the support for multiple ids.
184
 
    
185
 
    :param trailing_eol: If True end the last line with \n.
186
 
    :param key_length: The length of keys in files. Currently supports length 1
187
 
        and 2 keys.
188
 
    :param left_only: If True do not add the right and merged nodes.
189
 
    :param nograph: If True, do not provide parents to the add_lines calls;
190
 
        this is useful for tests that need inserted data but have graphless
191
 
        stores.
192
 
    :return: The results of the add_lines calls.
193
 
    """
194
 
    if key_length == 1:
195
 
        prefixes = [()]
196
 
    else:
197
 
        prefixes = [('FileA',), ('FileB',)]
198
 
    # insert a diamond graph to exercise deltas and merges.
199
 
    if trailing_eol:
200
 
        last_char = '\n'
201
 
    else:
202
 
        last_char = ''
203
 
    result = []
204
 
    def get_parents(suffix_list):
205
 
        if nograph:
206
 
            return ()
207
 
        else:
208
 
            result = [prefix + suffix for suffix in suffix_list]
209
 
            return result
210
 
    # we loop over each key because that spreads the inserts across prefixes,
211
 
    # which is how commit operates.
212
 
    for prefix in prefixes:
213
 
        result.append(files.add_lines(prefix + ('origin',), (),
214
 
            ['origin' + last_char]))
215
 
    for prefix in prefixes:
216
 
        result.append(files.add_lines(prefix + ('base',),
217
 
            get_parents([('origin',)]), ['base' + last_char]))
218
 
    for prefix in prefixes:
219
 
        result.append(files.add_lines(prefix + ('left',),
220
 
            get_parents([('base',)]),
221
 
            ['base\n', 'left' + last_char]))
222
 
    if not left_only:
223
 
        for prefix in prefixes:
224
 
            result.append(files.add_lines(prefix + ('right',),
225
 
                get_parents([('base',)]),
226
 
                ['base\n', 'right' + last_char]))
227
 
        for prefix in prefixes:
228
 
            result.append(files.add_lines(prefix + ('merged',),
229
 
                get_parents([('left',), ('right',)]),
230
 
                ['base\n', 'left\n', 'right\n', 'merged' + last_char]))
231
 
    return result
232
 
 
233
 
 
234
46
class VersionedFileTestMixIn(object):
235
47
    """A mixin test class for testing VersionedFiles.
236
48
 
239
51
    they are strictly controlled by their owning repositories.
240
52
    """
241
53
 
242
 
    def get_transaction(self):
243
 
        if not hasattr(self, '_transaction'):
244
 
            self._transaction = None
245
 
        return self._transaction
246
 
 
247
54
    def test_add(self):
248
55
        f = self.get_file()
249
56
        f.add_lines('r0', [], ['a\n', 'b\n'])
270
77
    def test_adds_with_parent_texts(self):
271
78
        f = self.get_file()
272
79
        parent_texts = {}
273
 
        _, _, parent_texts['r0'] = f.add_lines('r0', [], ['a\n', 'b\n'])
 
80
        parent_texts['r0'] = f.add_lines('r0', [], ['a\n', 'b\n'])
274
81
        try:
275
 
            _, _, parent_texts['r1'] = f.add_lines_with_ghosts('r1',
276
 
                ['r0', 'ghost'], ['b\n', 'c\n'], parent_texts=parent_texts)
 
82
            parent_texts['r1'] = f.add_lines_with_ghosts('r1',
 
83
                                                         ['r0', 'ghost'], 
 
84
                                                         ['b\n', 'c\n'],
 
85
                                                         parent_texts=parent_texts)
277
86
        except NotImplementedError:
278
87
            # if the format doesn't support ghosts, just add normally.
279
 
            _, _, parent_texts['r1'] = f.add_lines('r1',
280
 
                ['r0'], ['b\n', 'c\n'], parent_texts=parent_texts)
 
88
            parent_texts['r1'] = f.add_lines('r1',
 
89
                                             ['r0'], 
 
90
                                             ['b\n', 'c\n'],
 
91
                                             parent_texts=parent_texts)
281
92
        f.add_lines('r2', ['r1'], ['c\n', 'd\n'], parent_texts=parent_texts)
282
93
        self.assertNotEqual(None, parent_texts['r0'])
283
94
        self.assertNotEqual(None, parent_texts['r1'])
311
122
            (errors.BzrBadParameterUnicode, NotImplementedError),
312
123
            vf.add_lines_with_ghosts, 'a', [], ['a\n', u'b\n', 'c\n'])
313
124
 
314
 
    def test_add_follows_left_matching_blocks(self):
315
 
        """If we change left_matching_blocks, delta changes
316
 
 
317
 
        Note: There are multiple correct deltas in this case, because
318
 
        we start with 1 "a" and we get 3.
319
 
        """
320
 
        vf = self.get_file()
321
 
        if isinstance(vf, WeaveFile):
322
 
            raise TestSkipped("WeaveFile ignores left_matching_blocks")
323
 
        vf.add_lines('1', [], ['a\n'])
324
 
        vf.add_lines('2', ['1'], ['a\n', 'a\n', 'a\n'],
325
 
                     left_matching_blocks=[(0, 0, 1), (1, 3, 0)])
326
 
        self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('2'))
327
 
        vf.add_lines('3', ['1'], ['a\n', 'a\n', 'a\n'],
328
 
                     left_matching_blocks=[(0, 2, 1), (1, 3, 0)])
329
 
        self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('3'))
330
 
 
331
125
    def test_inline_newline_throws(self):
332
126
        # \r characters are not permitted in lines being added
333
127
        vf = self.get_file()
343
137
        except NotImplementedError:
344
138
            pass
345
139
 
346
 
    def test_add_reserved(self):
347
 
        vf = self.get_file()
348
 
        self.assertRaises(errors.ReservedId,
349
 
            vf.add_lines, 'a:', [], ['a\n', 'b\n', 'c\n'])
350
 
 
351
 
    def test_add_lines_nostoresha(self):
352
 
        """When nostore_sha is supplied using old content raises."""
353
 
        vf = self.get_file()
354
 
        empty_text = ('a', [])
355
 
        sample_text_nl = ('b', ["foo\n", "bar\n"])
356
 
        sample_text_no_nl = ('c', ["foo\n", "bar"])
357
 
        shas = []
358
 
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
359
 
            sha, _, _ = vf.add_lines(version, [], lines)
360
 
            shas.append(sha)
361
 
        # we now have a copy of all the lines in the vf.
362
 
        for sha, (version, lines) in zip(
363
 
            shas, (empty_text, sample_text_nl, sample_text_no_nl)):
364
 
            self.assertRaises(errors.ExistingContent,
365
 
                vf.add_lines, version + "2", [], lines,
366
 
                nostore_sha=sha)
367
 
            # and no new version should have been added.
368
 
            self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
369
 
                version + "2")
370
 
 
371
 
    def test_add_lines_with_ghosts_nostoresha(self):
372
 
        """When nostore_sha is supplied using old content raises."""
373
 
        vf = self.get_file()
374
 
        empty_text = ('a', [])
375
 
        sample_text_nl = ('b', ["foo\n", "bar\n"])
376
 
        sample_text_no_nl = ('c', ["foo\n", "bar"])
377
 
        shas = []
378
 
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
379
 
            sha, _, _ = vf.add_lines(version, [], lines)
380
 
            shas.append(sha)
381
 
        # we now have a copy of all the lines in the vf.
382
 
        # is the test applicable to this vf implementation?
383
 
        try:
384
 
            vf.add_lines_with_ghosts('d', [], [])
385
 
        except NotImplementedError:
386
 
            raise TestSkipped("add_lines_with_ghosts is optional")
387
 
        for sha, (version, lines) in zip(
388
 
            shas, (empty_text, sample_text_nl, sample_text_no_nl)):
389
 
            self.assertRaises(errors.ExistingContent,
390
 
                vf.add_lines_with_ghosts, version + "2", [], lines,
391
 
                nostore_sha=sha)
392
 
            # and no new version should have been added.
393
 
            self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
394
 
                version + "2")
395
 
 
396
 
    def test_add_lines_return_value(self):
397
 
        # add_lines should return the sha1 and the text size.
398
 
        vf = self.get_file()
399
 
        empty_text = ('a', [])
400
 
        sample_text_nl = ('b', ["foo\n", "bar\n"])
401
 
        sample_text_no_nl = ('c', ["foo\n", "bar"])
402
 
        # check results for the three cases:
403
 
        for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
404
 
            # the first two elements are the same for all versioned files:
405
 
            # - the digest and the size of the text. For some versioned files
406
 
            #   additional data is returned in additional tuple elements.
407
 
            result = vf.add_lines(version, [], lines)
408
 
            self.assertEqual(3, len(result))
409
 
            self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
410
 
                result[0:2])
411
 
        # parents should not affect the result:
412
 
        lines = sample_text_nl[1]
413
 
        self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
414
 
            vf.add_lines('d', ['b', 'c'], lines)[0:2])
415
 
 
416
 
    def test_get_reserved(self):
417
 
        vf = self.get_file()
418
 
        self.assertRaises(errors.ReservedId, vf.get_texts, ['b:'])
419
 
        self.assertRaises(errors.ReservedId, vf.get_lines, 'b:')
420
 
        self.assertRaises(errors.ReservedId, vf.get_text, 'b:')
421
 
 
422
 
    def test_add_unchanged_last_line_noeol_snapshot(self):
423
 
        """Add a text with an unchanged last line with no eol should work."""
424
 
        # Test adding this in a number of chain lengths; because the interface
425
 
        # for VersionedFile does not allow forcing a specific chain length, we
426
 
        # just use a small base to get the first snapshot, then a much longer
427
 
        # first line for the next add (which will make the third add snapshot)
428
 
        # and so on. 20 has been chosen as an aribtrary figure - knits use 200
429
 
        # as a capped delta length, but ideally we would have some way of
430
 
        # tuning the test to the store (e.g. keep going until a snapshot
431
 
        # happens).
432
 
        for length in range(20):
433
 
            version_lines = {}
434
 
            vf = self.get_file('case-%d' % length)
435
 
            prefix = 'step-%d'
436
 
            parents = []
437
 
            for step in range(length):
438
 
                version = prefix % step
439
 
                lines = (['prelude \n'] * step) + ['line']
440
 
                vf.add_lines(version, parents, lines)
441
 
                version_lines[version] = lines
442
 
                parents = [version]
443
 
            vf.add_lines('no-eol', parents, ['line'])
444
 
            vf.get_texts(version_lines.keys())
445
 
            self.assertEqualDiff('line', vf.get_text('no-eol'))
446
 
 
447
 
    def test_get_texts_eol_variation(self):
448
 
        # similar to the failure in <http://bugs.launchpad.net/234748>
449
 
        vf = self.get_file()
450
 
        sample_text_nl = ["line\n"]
451
 
        sample_text_no_nl = ["line"]
452
 
        versions = []
453
 
        version_lines = {}
454
 
        parents = []
455
 
        for i in range(4):
456
 
            version = 'v%d' % i
457
 
            if i % 2:
458
 
                lines = sample_text_nl
459
 
            else:
460
 
                lines = sample_text_no_nl
461
 
            # left_matching blocks is an internal api; it operates on the
462
 
            # *internal* representation for a knit, which is with *all* lines
463
 
            # being normalised to end with \n - even the final line in a no_nl
464
 
            # file. Using it here ensures that a broken internal implementation
465
 
            # (which is what this test tests) will generate a correct line
466
 
            # delta (which is to say, an empty delta).
467
 
            vf.add_lines(version, parents, lines,
468
 
                left_matching_blocks=[(0, 0, 1)])
469
 
            parents = [version]
470
 
            versions.append(version)
471
 
            version_lines[version] = lines
472
 
        vf.check()
473
 
        vf.get_texts(versions)
474
 
        vf.get_texts(reversed(versions))
475
 
 
476
 
    def test_add_lines_with_matching_blocks_noeol_last_line(self):
477
 
        """Add a text with an unchanged last line with no eol should work."""
478
 
        from bzrlib import multiparent
479
 
        # Hand verified sha1 of the text we're adding.
480
 
        sha1 = '6a1d115ec7b60afb664dc14890b5af5ce3c827a4'
481
 
        # Create a mpdiff which adds a new line before the trailing line, and
482
 
        # reuse the last line unaltered (which can cause annotation reuse).
483
 
        # Test adding this in two situations:
484
 
        # On top of a new insertion
485
 
        vf = self.get_file('fulltext')
486
 
        vf.add_lines('noeol', [], ['line'])
487
 
        vf.add_lines('noeol2', ['noeol'], ['newline\n', 'line'],
488
 
            left_matching_blocks=[(0, 1, 1)])
489
 
        self.assertEqualDiff('newline\nline', vf.get_text('noeol2'))
490
 
        # On top of a delta
491
 
        vf = self.get_file('delta')
492
 
        vf.add_lines('base', [], ['line'])
493
 
        vf.add_lines('noeol', ['base'], ['prelude\n', 'line'])
494
 
        vf.add_lines('noeol2', ['noeol'], ['newline\n', 'line'],
495
 
            left_matching_blocks=[(1, 1, 1)])
496
 
        self.assertEqualDiff('newline\nline', vf.get_text('noeol2'))
497
 
 
498
 
    def test_make_mpdiffs(self):
499
 
        from bzrlib import multiparent
500
 
        vf = self.get_file('foo')
501
 
        sha1s = self._setup_for_deltas(vf)
502
 
        new_vf = self.get_file('bar')
503
 
        for version in multiparent.topo_iter(vf):
504
 
            mpdiff = vf.make_mpdiffs([version])[0]
505
 
            new_vf.add_mpdiffs([(version, vf.get_parent_map([version])[version],
506
 
                                 vf.get_sha1s([version])[version], mpdiff)])
507
 
            self.assertEqualDiff(vf.get_text(version),
508
 
                                 new_vf.get_text(version))
509
 
 
510
 
    def test_make_mpdiffs_with_ghosts(self):
511
 
        vf = self.get_file('foo')
512
 
        try:
513
 
            vf.add_lines_with_ghosts('text', ['ghost'], ['line\n'])
514
 
        except NotImplementedError:
515
 
            # old Weave formats do not allow ghosts
516
 
            return
517
 
        self.assertRaises(errors.RevisionNotPresent, vf.make_mpdiffs, ['ghost'])
 
140
    def test_get_delta(self):
 
141
        f = self.get_file()
 
142
        sha1s = self._setup_for_deltas(f)
 
143
        expected_delta = (None, '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
 
144
                          [(0, 0, 1, [('base', 'line\n')])])
 
145
        self.assertEqual(expected_delta, f.get_delta('base'))
 
146
        next_parent = 'base'
 
147
        text_name = 'chain1-'
 
148
        for depth in range(26):
 
149
            new_version = text_name + '%s' % depth
 
150
            expected_delta = (next_parent, sha1s[depth], 
 
151
                              False,
 
152
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
 
153
            self.assertEqual(expected_delta, f.get_delta(new_version))
 
154
            next_parent = new_version
 
155
        next_parent = 'base'
 
156
        text_name = 'chain2-'
 
157
        for depth in range(26):
 
158
            new_version = text_name + '%s' % depth
 
159
            expected_delta = (next_parent, sha1s[depth], False,
 
160
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
 
161
            self.assertEqual(expected_delta, f.get_delta(new_version))
 
162
            next_parent = new_version
 
163
        # smoke test for eol support
 
164
        expected_delta = ('base', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, [])
 
165
        self.assertEqual(['line'], f.get_lines('noeol'))
 
166
        self.assertEqual(expected_delta, f.get_delta('noeol'))
 
167
 
 
168
    def test_get_deltas(self):
 
169
        f = self.get_file()
 
170
        sha1s = self._setup_for_deltas(f)
 
171
        deltas = f.get_deltas(f.versions())
 
172
        expected_delta = (None, '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
 
173
                          [(0, 0, 1, [('base', 'line\n')])])
 
174
        self.assertEqual(expected_delta, deltas['base'])
 
175
        next_parent = 'base'
 
176
        text_name = 'chain1-'
 
177
        for depth in range(26):
 
178
            new_version = text_name + '%s' % depth
 
179
            expected_delta = (next_parent, sha1s[depth], 
 
180
                              False,
 
181
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
 
182
            self.assertEqual(expected_delta, deltas[new_version])
 
183
            next_parent = new_version
 
184
        next_parent = 'base'
 
185
        text_name = 'chain2-'
 
186
        for depth in range(26):
 
187
            new_version = text_name + '%s' % depth
 
188
            expected_delta = (next_parent, sha1s[depth], False,
 
189
                              [(depth + 1, depth + 1, 1, [(new_version, 'line\n')])])
 
190
            self.assertEqual(expected_delta, deltas[new_version])
 
191
            next_parent = new_version
 
192
        # smoke tests for eol support
 
193
        expected_delta = ('base', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, [])
 
194
        self.assertEqual(['line'], f.get_lines('noeol'))
 
195
        self.assertEqual(expected_delta, deltas['noeol'])
 
196
        # smoke tests for eol support - two noeol in a row same content
 
197
        expected_deltas = (('noeol', '3ad7ee82dbd8f29ecba073f96e43e414b3f70a4d', True, 
 
198
                          [(0, 1, 2, [(u'noeolsecond', 'line\n'), (u'noeolsecond', 'line\n')])]),
 
199
                          ('noeol', '3ad7ee82dbd8f29ecba073f96e43e414b3f70a4d', True, 
 
200
                           [(0, 0, 1, [('noeolsecond', 'line\n')]), (1, 1, 0, [])]))
 
201
        self.assertEqual(['line\n', 'line'], f.get_lines('noeolsecond'))
 
202
        self.assertTrue(deltas['noeolsecond'] in expected_deltas)
 
203
        # two no-eol in a row, different content
 
204
        expected_delta = ('noeolsecond', '8bb553a84e019ef1149db082d65f3133b195223b', True, 
 
205
                          [(1, 2, 1, [(u'noeolnotshared', 'phone\n')])])
 
206
        self.assertEqual(['line\n', 'phone'], f.get_lines('noeolnotshared'))
 
207
        self.assertEqual(expected_delta, deltas['noeolnotshared'])
 
208
        # eol folling a no-eol with content change
 
209
        expected_delta = ('noeol', 'a61f6fb6cfc4596e8d88c34a308d1e724caf8977', False, 
 
210
                          [(0, 1, 1, [(u'eol', 'phone\n')])])
 
211
        self.assertEqual(['phone\n'], f.get_lines('eol'))
 
212
        self.assertEqual(expected_delta, deltas['eol'])
 
213
        # eol folling a no-eol with content change
 
214
        expected_delta = ('noeol', '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
 
215
                          [(0, 1, 1, [(u'eolline', 'line\n')])])
 
216
        self.assertEqual(['line\n'], f.get_lines('eolline'))
 
217
        self.assertEqual(expected_delta, deltas['eolline'])
 
218
        # eol with no parents
 
219
        expected_delta = (None, '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, 
 
220
                          [(0, 0, 1, [(u'noeolbase', 'line\n')])])
 
221
        self.assertEqual(['line'], f.get_lines('noeolbase'))
 
222
        self.assertEqual(expected_delta, deltas['noeolbase'])
 
223
        # eol with two parents, in inverse insertion order
 
224
        expected_deltas = (('noeolbase', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True,
 
225
                            [(0, 1, 1, [(u'eolbeforefirstparent', 'line\n')])]),
 
226
                           ('noeolbase', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True,
 
227
                            [(0, 1, 1, [(u'eolbeforefirstparent', 'line\n')])]))
 
228
        self.assertEqual(['line'], f.get_lines('eolbeforefirstparent'))
 
229
        #self.assertTrue(deltas['eolbeforefirstparent'] in expected_deltas)
518
230
 
519
231
    def _setup_for_deltas(self, f):
520
 
        self.assertFalse(f.has_version('base'))
 
232
        self.assertRaises(errors.RevisionNotPresent, f.get_delta, 'base')
521
233
        # add texts that should trip the knit maximum delta chain threshold
522
234
        # as well as doing parallel chains of data in knits.
523
235
        # this is done by two chains of 25 insertions
586
298
            next_parent = new_version
587
299
        return sha1s
588
300
 
 
301
    def test_add_delta(self):
 
302
        # tests for the add-delta facility.
 
303
        # at this point, optimising for speed, we assume no checks when deltas are inserted.
 
304
        # this may need to be revisited.
 
305
        source = self.get_file('source')
 
306
        source.add_lines('base', [], ['line\n'])
 
307
        next_parent = 'base'
 
308
        text_name = 'chain1-'
 
309
        text = ['line\n']
 
310
        for depth in range(26):
 
311
            new_version = text_name + '%s' % depth
 
312
            text = text + ['line\n']
 
313
            source.add_lines(new_version, [next_parent], text)
 
314
            next_parent = new_version
 
315
        next_parent = 'base'
 
316
        text_name = 'chain2-'
 
317
        text = ['line\n']
 
318
        for depth in range(26):
 
319
            new_version = text_name + '%s' % depth
 
320
            text = text + ['line\n']
 
321
            source.add_lines(new_version, [next_parent], text)
 
322
            next_parent = new_version
 
323
        source.add_lines('noeol', ['base'], ['line'])
 
324
        
 
325
        target = self.get_file('target')
 
326
        for version in source.versions():
 
327
            parent, sha1, noeol, delta = source.get_delta(version)
 
328
            target.add_delta(version,
 
329
                             source.get_parents(version),
 
330
                             parent,
 
331
                             sha1,
 
332
                             noeol,
 
333
                             delta)
 
334
        self.assertRaises(RevisionAlreadyPresent,
 
335
                          target.add_delta, 'base', [], None, '', False, [])
 
336
        for version in source.versions():
 
337
            self.assertEqual(source.get_lines(version),
 
338
                             target.get_lines(version))
 
339
 
589
340
    def test_ancestry(self):
590
341
        f = self.get_file()
591
342
        self.assertEqual([], f.get_ancestry([]))
614
365
        self.assertRaises(RevisionNotPresent,
615
366
            f.get_ancestry, ['rM', 'rX'])
616
367
 
617
 
        self.assertEqual(set(f.get_ancestry('rM')),
618
 
            set(f.get_ancestry('rM', topo_sorted=False)))
619
 
 
620
368
    def test_mutate_after_finish(self):
621
 
        self._transaction = 'before'
622
369
        f = self.get_file()
623
 
        self._transaction = 'after'
 
370
        f.transaction_finished()
 
371
        self.assertRaises(errors.OutSideTransaction, f.add_delta, '', [], '', '', False, [])
624
372
        self.assertRaises(errors.OutSideTransaction, f.add_lines, '', [], [])
625
373
        self.assertRaises(errors.OutSideTransaction, f.add_lines_with_ghosts, '', [], [])
 
374
        self.assertRaises(errors.OutSideTransaction, f.fix_parents, '', [])
 
375
        self.assertRaises(errors.OutSideTransaction, f.join, '')
 
376
        self.assertRaises(errors.OutSideTransaction, f.clone_text, 'base', 'bar', ['foo'])
626
377
        
 
378
    def test_clear_cache(self):
 
379
        f = self.get_file()
 
380
        # on a new file it should not error
 
381
        f.clear_cache()
 
382
        # and after adding content, doing a clear_cache and a get should work.
 
383
        f.add_lines('0', [], ['a'])
 
384
        f.clear_cache()
 
385
        self.assertEqual(['a'], f.get_lines('0'))
 
386
 
 
387
    def test_clone_text(self):
 
388
        f = self.get_file()
 
389
        f.add_lines('r0', [], ['a\n', 'b\n'])
 
390
        f.clone_text('r1', 'r0', ['r0'])
 
391
        def verify_file(f):
 
392
            self.assertEquals(f.get_lines('r1'), f.get_lines('r0'))
 
393
            self.assertEquals(f.get_lines('r1'), ['a\n', 'b\n'])
 
394
            self.assertEquals(f.get_parents('r1'), ['r0'])
 
395
    
 
396
            self.assertRaises(RevisionNotPresent,
 
397
                f.clone_text, 'r2', 'rX', [])
 
398
            self.assertRaises(RevisionAlreadyPresent,
 
399
                f.clone_text, 'r1', 'r0', [])
 
400
        verify_file(f)
 
401
        verify_file(self.reopen_file())
 
402
 
 
403
    def test_create_empty(self):
 
404
        f = self.get_file()
 
405
        f.add_lines('0', [], ['a\n'])
 
406
        new_f = f.create_empty('t', MemoryTransport())
 
407
        # smoke test, specific types should check it is honoured correctly for
 
408
        # non type attributes
 
409
        self.assertEqual([], new_f.versions())
 
410
        self.assertTrue(isinstance(new_f, f.__class__))
 
411
 
627
412
    def test_copy_to(self):
628
413
        f = self.get_file()
629
414
        f.add_lines('0', [], ['a\n'])
630
415
        t = MemoryTransport()
631
416
        f.copy_to('foo', t)
632
 
        for suffix in self.get_factory().get_suffixes():
 
417
        for suffix in f.__class__.get_suffixes():
633
418
            self.assertTrue(t.has('foo' + suffix))
634
419
 
635
420
    def test_get_suffixes(self):
636
421
        f = self.get_file()
 
422
        # should be the same
 
423
        self.assertEqual(f.__class__.get_suffixes(), f.__class__.get_suffixes())
637
424
        # and should be a list
638
 
        self.assertTrue(isinstance(self.get_factory().get_suffixes(), list))
639
 
 
640
 
    def test_get_parent_map(self):
 
425
        self.assertTrue(isinstance(f.__class__.get_suffixes(), list))
 
426
 
 
427
    def build_graph(self, file, graph):
 
428
        for node in topo_sort(graph.items()):
 
429
            file.add_lines(node, graph[node], [])
 
430
 
 
431
    def test_get_graph(self):
 
432
        f = self.get_file()
 
433
        graph = {
 
434
            'v1': [],
 
435
            'v2': ['v1'],
 
436
            'v3': ['v2']}
 
437
        self.build_graph(f, graph)
 
438
        self.assertEqual(graph, f.get_graph())
 
439
    
 
440
    def test_get_graph_partial(self):
 
441
        f = self.get_file()
 
442
        complex_graph = {}
 
443
        simple_a = {
 
444
            'c': [],
 
445
            'b': ['c'],
 
446
            'a': ['b'],
 
447
            }
 
448
        complex_graph.update(simple_a)
 
449
        simple_b = {
 
450
            'c': [],
 
451
            'b': ['c'],
 
452
            }
 
453
        complex_graph.update(simple_b)
 
454
        simple_gam = {
 
455
            'c': [],
 
456
            'oo': [],
 
457
            'bar': ['oo', 'c'],
 
458
            'gam': ['bar'],
 
459
            }
 
460
        complex_graph.update(simple_gam)
 
461
        simple_b_gam = {}
 
462
        simple_b_gam.update(simple_gam)
 
463
        simple_b_gam.update(simple_b)
 
464
        self.build_graph(f, complex_graph)
 
465
        self.assertEqual(simple_a, f.get_graph(['a']))
 
466
        self.assertEqual(simple_b, f.get_graph(['b']))
 
467
        self.assertEqual(simple_gam, f.get_graph(['gam']))
 
468
        self.assertEqual(simple_b_gam, f.get_graph(['b', 'gam']))
 
469
 
 
470
    def test_get_parents(self):
641
471
        f = self.get_file()
642
472
        f.add_lines('r0', [], ['a\n', 'b\n'])
643
 
        self.assertEqual(
644
 
            {'r0':()}, f.get_parent_map(['r0']))
645
 
        f.add_lines('r1', ['r0'], ['a\n', 'b\n'])
646
 
        self.assertEqual(
647
 
            {'r1':('r0',)}, f.get_parent_map(['r1']))
648
 
        self.assertEqual(
649
 
            {'r0':(),
650
 
             'r1':('r0',)},
651
 
            f.get_parent_map(['r0', 'r1']))
 
473
        f.add_lines('r1', [], ['a\n', 'b\n'])
652
474
        f.add_lines('r2', [], ['a\n', 'b\n'])
653
475
        f.add_lines('r3', [], ['a\n', 'b\n'])
654
476
        f.add_lines('m', ['r0', 'r1', 'r2', 'r3'], ['a\n', 'b\n'])
655
 
        self.assertEqual(
656
 
            {'m':('r0', 'r1', 'r2', 'r3')}, f.get_parent_map(['m']))
657
 
        self.assertEqual({}, f.get_parent_map('y'))
658
 
        self.assertEqual(
659
 
            {'r0':(),
660
 
             'r1':('r0',)},
661
 
            f.get_parent_map(['r0', 'y', 'r1']))
 
477
        self.assertEquals(f.get_parents('m'), ['r0', 'r1', 'r2', 'r3'])
 
478
 
 
479
        self.assertRaises(RevisionNotPresent,
 
480
            f.get_parents, 'y')
662
481
 
663
482
    def test_annotate(self):
664
483
        f = self.get_file()
671
490
        self.assertRaises(RevisionNotPresent,
672
491
            f.annotate, 'foo')
673
492
 
 
493
    def test_walk(self):
 
494
        # tests that walk returns all the inclusions for the requested
 
495
        # revisions as well as the revisions changes themselves.
 
496
        f = self.get_file('1')
 
497
        f.add_lines('r0', [], ['a\n', 'b\n'])
 
498
        f.add_lines('r1', ['r0'], ['c\n', 'b\n'])
 
499
        f.add_lines('rX', ['r1'], ['d\n', 'b\n'])
 
500
        f.add_lines('rY', ['r1'], ['c\n', 'e\n'])
 
501
 
 
502
        lines = {}
 
503
        for lineno, insert, dset, text in f.walk(['rX', 'rY']):
 
504
            lines[text] = (insert, dset)
 
505
 
 
506
        self.assertTrue(lines['a\n'], ('r0', set(['r1'])))
 
507
        self.assertTrue(lines['b\n'], ('r0', set(['rY'])))
 
508
        self.assertTrue(lines['c\n'], ('r1', set(['rX'])))
 
509
        self.assertTrue(lines['d\n'], ('rX', set([])))
 
510
        self.assertTrue(lines['e\n'], ('rY', set([])))
 
511
 
674
512
    def test_detection(self):
675
513
        # Test weaves detect corruption.
676
514
        #
705
543
        # versions in the weave 
706
544
        # the ordering here is to make a tree so that dumb searches have
707
545
        # more changes to muck up.
708
 
 
709
 
        class InstrumentedProgress(progress.DummyProgress):
710
 
 
711
 
            def __init__(self):
712
 
 
713
 
                progress.DummyProgress.__init__(self)
714
 
                self.updates = []
715
 
 
716
 
            def update(self, msg=None, current=None, total=None):
717
 
                self.updates.append((msg, current, total))
718
 
 
719
546
        vf = self.get_file()
720
547
        # add a base to get included
721
548
        vf.add_lines('base', [], ['base\n'])
729
556
        vf.add_lines('otherchild',
730
557
                     ['lancestor', 'base'],
731
558
                     ['base\n', 'lancestor\n', 'otherchild\n'])
732
 
        def iter_with_versions(versions, expected):
 
559
        def iter_with_versions(versions):
733
560
            # now we need to see what lines are returned, and how often.
734
 
            lines = {}
735
 
            progress = InstrumentedProgress()
 
561
            lines = {'base\n':0,
 
562
                     'lancestor\n':0,
 
563
                     'rancestor\n':0,
 
564
                     'child\n':0,
 
565
                     'otherchild\n':0,
 
566
                     }
736
567
            # iterate over the lines
737
 
            for line in vf.iter_lines_added_or_present_in_versions(versions,
738
 
                pb=progress):
739
 
                lines.setdefault(line, 0)
 
568
            for line in vf.iter_lines_added_or_present_in_versions(versions):
740
569
                lines[line] += 1
741
 
            if []!= progress.updates:
742
 
                self.assertEqual(expected, progress.updates)
743
570
            return lines
744
 
        lines = iter_with_versions(['child', 'otherchild'],
745
 
                                   [('Walking content.', 0, 2),
746
 
                                    ('Walking content.', 1, 2),
747
 
                                    ('Walking content.', 2, 2)])
 
571
        lines = iter_with_versions(['child', 'otherchild'])
748
572
        # we must see child and otherchild
749
 
        self.assertTrue(lines[('child\n', 'child')] > 0)
750
 
        self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
 
573
        self.assertTrue(lines['child\n'] > 0)
 
574
        self.assertTrue(lines['otherchild\n'] > 0)
751
575
        # we dont care if we got more than that.
752
576
        
753
577
        # test all lines
754
 
        lines = iter_with_versions(None, [('Walking content.', 0, 5),
755
 
                                          ('Walking content.', 1, 5),
756
 
                                          ('Walking content.', 2, 5),
757
 
                                          ('Walking content.', 3, 5),
758
 
                                          ('Walking content.', 4, 5),
759
 
                                          ('Walking content.', 5, 5)])
 
578
        lines = iter_with_versions(None)
760
579
        # all lines must be seen at least once
761
 
        self.assertTrue(lines[('base\n', 'base')] > 0)
762
 
        self.assertTrue(lines[('lancestor\n', 'lancestor')] > 0)
763
 
        self.assertTrue(lines[('rancestor\n', 'rancestor')] > 0)
764
 
        self.assertTrue(lines[('child\n', 'child')] > 0)
765
 
        self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
 
580
        self.assertTrue(lines['base\n'] > 0)
 
581
        self.assertTrue(lines['lancestor\n'] > 0)
 
582
        self.assertTrue(lines['rancestor\n'] > 0)
 
583
        self.assertTrue(lines['child\n'] > 0)
 
584
        self.assertTrue(lines['otherchild\n'] > 0)
 
585
 
 
586
    def test_fix_parents(self):
 
587
        # some versioned files allow incorrect parents to be corrected after
 
588
        # insertion - this may not fix ancestry..
 
589
        # if they do not supported, they just do not implement it.
 
590
        # we test this as an interface test to ensure that those that *do*
 
591
        # implementent it get it right.
 
592
        vf = self.get_file()
 
593
        vf.add_lines('notbase', [], [])
 
594
        vf.add_lines('base', [], [])
 
595
        try:
 
596
            vf.fix_parents('notbase', ['base'])
 
597
        except NotImplementedError:
 
598
            return
 
599
        self.assertEqual(['base'], vf.get_parents('notbase'))
 
600
        # open again, check it stuck.
 
601
        vf = self.get_file()
 
602
        self.assertEqual(['base'], vf.get_parents('notbase'))
 
603
 
 
604
    def test_fix_parents_with_ghosts(self):
 
605
        # when fixing parents, ghosts that are listed should not be ghosts
 
606
        # anymore.
 
607
        vf = self.get_file()
 
608
 
 
609
        try:
 
610
            vf.add_lines_with_ghosts('notbase', ['base', 'stillghost'], [])
 
611
        except NotImplementedError:
 
612
            return
 
613
        vf.add_lines('base', [], [])
 
614
        vf.fix_parents('notbase', ['base', 'stillghost'])
 
615
        self.assertEqual(['base'], vf.get_parents('notbase'))
 
616
        # open again, check it stuck.
 
617
        vf = self.get_file()
 
618
        self.assertEqual(['base'], vf.get_parents('notbase'))
 
619
        # and check the ghosts
 
620
        self.assertEqual(['base', 'stillghost'],
 
621
                         vf.get_parents_with_ghosts('notbase'))
766
622
 
767
623
    def test_add_lines_with_ghosts(self):
768
624
        # some versioned file formats allow lines to be added with parent
771
627
        # add_lines_with_ghosts api.
772
628
        vf = self.get_file()
773
629
        # add a revision with ghost parents
774
 
        # The preferred form is utf8, but we should translate when needed
775
 
        parent_id_unicode = u'b\xbfse'
776
 
        parent_id_utf8 = parent_id_unicode.encode('utf8')
777
630
        try:
778
 
            vf.add_lines_with_ghosts('notbxbfse', [parent_id_utf8], [])
 
631
            vf.add_lines_with_ghosts(u'notbxbfse', [u'b\xbfse'], [])
779
632
        except NotImplementedError:
780
633
            # check the other ghost apis are also not implemented
 
634
            self.assertRaises(NotImplementedError, vf.has_ghost, 'foo')
781
635
            self.assertRaises(NotImplementedError, vf.get_ancestry_with_ghosts, ['foo'])
782
636
            self.assertRaises(NotImplementedError, vf.get_parents_with_ghosts, 'foo')
 
637
            self.assertRaises(NotImplementedError, vf.get_graph_with_ghosts)
783
638
            return
784
 
        vf = self.reopen_file()
785
639
        # test key graph related apis: getncestry, _graph, get_parents
786
640
        # has_version
787
641
        # - these are ghost unaware and must not be reflect ghosts
788
 
        self.assertEqual(['notbxbfse'], vf.get_ancestry('notbxbfse'))
789
 
        self.assertFalse(vf.has_version(parent_id_utf8))
 
642
        self.assertEqual([u'notbxbfse'], vf.get_ancestry(u'notbxbfse'))
 
643
        self.assertEqual([], vf.get_parents(u'notbxbfse'))
 
644
        self.assertEqual({u'notbxbfse':[]}, vf.get_graph())
 
645
        self.assertFalse(vf.has_version(u'b\xbfse'))
790
646
        # we have _with_ghost apis to give us ghost information.
791
 
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry_with_ghosts(['notbxbfse']))
792
 
        self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
 
647
        self.assertEqual([u'b\xbfse', u'notbxbfse'], vf.get_ancestry_with_ghosts([u'notbxbfse']))
 
648
        self.assertEqual([u'b\xbfse'], vf.get_parents_with_ghosts(u'notbxbfse'))
 
649
        self.assertEqual({u'notbxbfse':[u'b\xbfse']}, vf.get_graph_with_ghosts())
 
650
        self.assertTrue(vf.has_ghost(u'b\xbfse'))
793
651
        # if we add something that is a ghost of another, it should correct the
794
652
        # results of the prior apis
795
 
        vf.add_lines(parent_id_utf8, [], [])
796
 
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry(['notbxbfse']))
797
 
        self.assertEqual({'notbxbfse':(parent_id_utf8,)},
798
 
            vf.get_parent_map(['notbxbfse']))
799
 
        self.assertTrue(vf.has_version(parent_id_utf8))
 
653
        vf.add_lines(u'b\xbfse', [], [])
 
654
        self.assertEqual([u'b\xbfse', u'notbxbfse'], vf.get_ancestry([u'notbxbfse']))
 
655
        self.assertEqual([u'b\xbfse'], vf.get_parents(u'notbxbfse'))
 
656
        self.assertEqual({u'b\xbfse':[],
 
657
                          u'notbxbfse':[u'b\xbfse'],
 
658
                          },
 
659
                         vf.get_graph())
 
660
        self.assertTrue(vf.has_version(u'b\xbfse'))
800
661
        # we have _with_ghost apis to give us ghost information.
801
 
        self.assertEqual([parent_id_utf8, 'notbxbfse'],
802
 
            vf.get_ancestry_with_ghosts(['notbxbfse']))
803
 
        self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
 
662
        self.assertEqual([u'b\xbfse', u'notbxbfse'], vf.get_ancestry_with_ghosts([u'notbxbfse']))
 
663
        self.assertEqual([u'b\xbfse'], vf.get_parents_with_ghosts(u'notbxbfse'))
 
664
        self.assertEqual({u'b\xbfse':[],
 
665
                          u'notbxbfse':[u'b\xbfse'],
 
666
                          },
 
667
                         vf.get_graph_with_ghosts())
 
668
        self.assertFalse(vf.has_ghost(u'b\xbfse'))
804
669
 
805
670
    def test_add_lines_with_ghosts_after_normal_revs(self):
806
671
        # some versioned file formats allow lines to be added with parent
810
675
        vf = self.get_file()
811
676
        # probe for ghost support
812
677
        try:
813
 
            vf.add_lines_with_ghosts('base', [], ['line\n', 'line_b\n'])
 
678
            vf.has_ghost('hoo')
814
679
        except NotImplementedError:
815
680
            return
 
681
        vf.add_lines_with_ghosts('base', [], ['line\n', 'line_b\n'])
816
682
        vf.add_lines_with_ghosts('references_ghost',
817
683
                                 ['base', 'a_ghost'],
818
684
                                 ['line\n', 'line_b\n', 'line_c\n'])
826
692
        factory = self.get_factory()
827
693
        vf = factory('id', transport, 0777, create=True, access_mode='w')
828
694
        vf = factory('id', transport, access_mode='r')
 
695
        self.assertRaises(errors.ReadOnlyError, vf.add_delta, '', [], '', '', False, [])
829
696
        self.assertRaises(errors.ReadOnlyError, vf.add_lines, 'base', [], [])
830
697
        self.assertRaises(errors.ReadOnlyError,
831
698
                          vf.add_lines_with_ghosts,
832
699
                          'base',
833
700
                          [],
834
701
                          [])
 
702
        self.assertRaises(errors.ReadOnlyError, vf.fix_parents, 'base', [])
 
703
        self.assertRaises(errors.ReadOnlyError, vf.join, 'base')
 
704
        self.assertRaises(errors.ReadOnlyError, vf.clone_text, 'base', 'bar', ['foo'])
835
705
    
836
 
    def test_get_sha1s(self):
 
706
    def test_get_sha1(self):
837
707
        # check the sha1 data is available
838
708
        vf = self.get_file()
839
709
        # a simple file
842
712
        vf.add_lines('b', ['a'], ['a\n'])
843
713
        # a file differing only in last newline.
844
714
        vf.add_lines('c', [], ['a'])
845
 
        self.assertEqual({
846
 
            'a': '3f786850e387550fdab836ed7e6dc881de23001b',
847
 
            'c': '86f7e437faa5a7fce15d1ddcb9eaeaea377667b8',
848
 
            'b': '3f786850e387550fdab836ed7e6dc881de23001b',
849
 
            },
850
 
            vf.get_sha1s(['a', 'c', 'b']))
 
715
        self.assertEqual(
 
716
            '3f786850e387550fdab836ed7e6dc881de23001b', vf.get_sha1('a'))
 
717
        self.assertEqual(
 
718
            '3f786850e387550fdab836ed7e6dc881de23001b', vf.get_sha1('b'))
 
719
        self.assertEqual(
 
720
            '86f7e437faa5a7fce15d1ddcb9eaeaea377667b8', vf.get_sha1('c'))
851
721
        
852
722
 
853
 
class TestWeave(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
 
723
class TestWeave(TestCaseWithTransport, VersionedFileTestMixIn):
854
724
 
855
725
    def get_file(self, name='foo'):
856
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=True,
857
 
            get_scope=self.get_transaction)
 
726
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
858
727
 
859
728
    def get_file_corrupted_text(self):
860
 
        w = WeaveFile('foo', get_transport(self.get_url('.')), create=True,
861
 
            get_scope=self.get_transaction)
 
729
        w = WeaveFile('foo', get_transport(self.get_url('.')), create=True)
862
730
        w.add_lines('v1', [], ['hello\n'])
863
731
        w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
864
732
        
892
760
        return w
893
761
 
894
762
    def reopen_file(self, name='foo', create=False):
895
 
        return WeaveFile(name, get_transport(self.get_url('.')), create=create,
896
 
            get_scope=self.get_transaction)
 
763
        return WeaveFile(name, get_transport(self.get_url('.')), create=create)
897
764
 
898
765
    def test_no_implicit_create(self):
899
766
        self.assertRaises(errors.NoSuchFile,
900
767
                          WeaveFile,
901
768
                          'foo',
902
 
                          get_transport(self.get_url('.')),
903
 
                          get_scope=self.get_transaction)
 
769
                          get_transport(self.get_url('.')))
904
770
 
905
771
    def get_factory(self):
906
772
        return WeaveFile
907
773
 
908
774
 
909
 
class TestPlanMergeVersionedFile(TestCaseWithMemoryTransport):
910
 
 
911
 
    def setUp(self):
912
 
        TestCaseWithMemoryTransport.setUp(self)
913
 
        mapper = PrefixMapper()
914
 
        factory = make_file_factory(True, mapper)
915
 
        self.vf1 = factory(self.get_transport('root-1'))
916
 
        self.vf2 = factory(self.get_transport('root-2'))
917
 
        self.plan_merge_vf = versionedfile._PlanMergeVersionedFile('root')
918
 
        self.plan_merge_vf.fallback_versionedfiles.extend([self.vf1, self.vf2])
919
 
 
920
 
    def test_add_lines(self):
921
 
        self.plan_merge_vf.add_lines(('root', 'a:'), [], [])
922
 
        self.assertRaises(ValueError, self.plan_merge_vf.add_lines,
923
 
            ('root', 'a'), [], [])
924
 
        self.assertRaises(ValueError, self.plan_merge_vf.add_lines,
925
 
            ('root', 'a:'), None, [])
926
 
        self.assertRaises(ValueError, self.plan_merge_vf.add_lines,
927
 
            ('root', 'a:'), [], None)
928
 
 
929
 
    def setup_abcde(self):
930
 
        self.vf1.add_lines(('root', 'A'), [], ['a'])
931
 
        self.vf1.add_lines(('root', 'B'), [('root', 'A')], ['b'])
932
 
        self.vf2.add_lines(('root', 'C'), [], ['c'])
933
 
        self.vf2.add_lines(('root', 'D'), [('root', 'C')], ['d'])
934
 
        self.plan_merge_vf.add_lines(('root', 'E:'),
935
 
            [('root', 'B'), ('root', 'D')], ['e'])
936
 
 
937
 
    def test_get_parents(self):
938
 
        self.setup_abcde()
939
 
        self.assertEqual({('root', 'B'):(('root', 'A'),)},
940
 
            self.plan_merge_vf.get_parent_map([('root', 'B')]))
941
 
        self.assertEqual({('root', 'D'):(('root', 'C'),)},
942
 
            self.plan_merge_vf.get_parent_map([('root', 'D')]))
943
 
        self.assertEqual({('root', 'E:'):(('root', 'B'),('root', 'D'))},
944
 
            self.plan_merge_vf.get_parent_map([('root', 'E:')]))
945
 
        self.assertEqual({},
946
 
            self.plan_merge_vf.get_parent_map([('root', 'F')]))
947
 
        self.assertEqual({
948
 
                ('root', 'B'):(('root', 'A'),),
949
 
                ('root', 'D'):(('root', 'C'),),
950
 
                ('root', 'E:'):(('root', 'B'),('root', 'D')),
951
 
                },
952
 
            self.plan_merge_vf.get_parent_map(
953
 
                [('root', 'B'), ('root', 'D'), ('root', 'E:'), ('root', 'F')]))
954
 
 
955
 
    def test_get_record_stream(self):
956
 
        self.setup_abcde()
957
 
        def get_record(suffix):
958
 
            return self.plan_merge_vf.get_record_stream(
959
 
                [('root', suffix)], 'unordered', True).next()
960
 
        self.assertEqual('a', get_record('A').get_bytes_as('fulltext'))
961
 
        self.assertEqual('c', get_record('C').get_bytes_as('fulltext'))
962
 
        self.assertEqual('e', get_record('E:').get_bytes_as('fulltext'))
963
 
        self.assertEqual('absent', get_record('F').storage_kind)
 
775
class TestKnit(TestCaseWithTransport, VersionedFileTestMixIn):
 
776
 
 
777
    def get_file(self, name='foo'):
 
778
        return KnitVersionedFile(name, get_transport(self.get_url('.')),
 
779
                                 delta=True, create=True)
 
780
 
 
781
    def get_factory(self):
 
782
        return KnitVersionedFile
 
783
 
 
784
    def get_file_corrupted_text(self):
 
785
        knit = self.get_file()
 
786
        knit.add_lines('v1', [], ['hello\n'])
 
787
        knit.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
 
788
        return knit
 
789
 
 
790
    def reopen_file(self, name='foo', create=False):
 
791
        return KnitVersionedFile(name, get_transport(self.get_url('.')),
 
792
            delta=True,
 
793
            create=create)
 
794
 
 
795
    def test_detection(self):
 
796
        knit = self.get_file()
 
797
        knit.check()
 
798
 
 
799
    def test_no_implicit_create(self):
 
800
        self.assertRaises(errors.NoSuchFile,
 
801
                          KnitVersionedFile,
 
802
                          'foo',
 
803
                          get_transport(self.get_url('.')))
 
804
 
 
805
 
 
806
class InterString(versionedfile.InterVersionedFile):
 
807
    """An inter-versionedfile optimised code path for strings.
 
808
 
 
809
    This is for use during testing where we use strings as versionedfiles
 
810
    so that none of the default regsitered interversionedfile classes will
 
811
    match - which lets us test the match logic.
 
812
    """
 
813
 
 
814
    @staticmethod
 
815
    def is_compatible(source, target):
 
816
        """InterString is compatible with strings-as-versionedfiles."""
 
817
        return isinstance(source, str) and isinstance(target, str)
 
818
 
 
819
 
 
820
# TODO this and the InterRepository core logic should be consolidatable
 
821
# if we make the registry a separate class though we still need to 
 
822
# test the behaviour in the active registry to catch failure-to-handle-
 
823
# stange-objects
 
824
class TestInterVersionedFile(TestCaseWithTransport):
 
825
 
 
826
    def test_get_default_inter_versionedfile(self):
 
827
        # test that the InterVersionedFile.get(a, b) probes
 
828
        # for a class where is_compatible(a, b) returns
 
829
        # true and returns a default interversionedfile otherwise.
 
830
        # This also tests that the default registered optimised interversionedfile
 
831
        # classes do not barf inappropriately when a surprising versionedfile type
 
832
        # is handed to them.
 
833
        dummy_a = "VersionedFile 1."
 
834
        dummy_b = "VersionedFile 2."
 
835
        self.assertGetsDefaultInterVersionedFile(dummy_a, dummy_b)
 
836
 
 
837
    def assertGetsDefaultInterVersionedFile(self, a, b):
 
838
        """Asserts that InterVersionedFile.get(a, b) -> the default."""
 
839
        inter = versionedfile.InterVersionedFile.get(a, b)
 
840
        self.assertEqual(versionedfile.InterVersionedFile,
 
841
                         inter.__class__)
 
842
        self.assertEqual(a, inter.source)
 
843
        self.assertEqual(b, inter.target)
 
844
 
 
845
    def test_register_inter_versionedfile_class(self):
 
846
        # test that a optimised code path provider - a
 
847
        # InterVersionedFile subclass can be registered and unregistered
 
848
        # and that it is correctly selected when given a versionedfile
 
849
        # pair that it returns true on for the is_compatible static method
 
850
        # check
 
851
        dummy_a = "VersionedFile 1."
 
852
        dummy_b = "VersionedFile 2."
 
853
        versionedfile.InterVersionedFile.register_optimiser(InterString)
 
854
        try:
 
855
            # we should get the default for something InterString returns False
 
856
            # to
 
857
            self.assertFalse(InterString.is_compatible(dummy_a, None))
 
858
            self.assertGetsDefaultInterVersionedFile(dummy_a, None)
 
859
            # and we should get an InterString for a pair it 'likes'
 
860
            self.assertTrue(InterString.is_compatible(dummy_a, dummy_b))
 
861
            inter = versionedfile.InterVersionedFile.get(dummy_a, dummy_b)
 
862
            self.assertEqual(InterString, inter.__class__)
 
863
            self.assertEqual(dummy_a, inter.source)
 
864
            self.assertEqual(dummy_b, inter.target)
 
865
        finally:
 
866
            versionedfile.InterVersionedFile.unregister_optimiser(InterString)
 
867
        # now we should get the default InterVersionedFile object again.
 
868
        self.assertGetsDefaultInterVersionedFile(dummy_a, dummy_b)
964
869
 
965
870
 
966
871
class TestReadonlyHttpMixin(object):
967
872
 
968
 
    def get_transaction(self):
969
 
        return 1
970
 
 
971
873
    def test_readonly_http_works(self):
972
874
        # we should be able to read from http with a versioned file.
973
875
        vf = self.get_file()
986
888
class TestWeaveHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
987
889
 
988
890
    def get_file(self):
989
 
        return WeaveFile('foo', get_transport(self.get_url('.')), create=True,
990
 
            get_scope=self.get_transaction)
 
891
        return WeaveFile('foo', get_transport(self.get_url('.')), create=True)
991
892
 
992
893
    def get_factory(self):
993
894
        return WeaveFile
994
895
 
995
896
 
 
897
class TestKnitHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
 
898
 
 
899
    def get_file(self):
 
900
        return KnitVersionedFile('foo', get_transport(self.get_url('.')),
 
901
                                 delta=True, create=True)
 
902
 
 
903
    def get_factory(self):
 
904
        return KnitVersionedFile
 
905
 
 
906
 
996
907
class MergeCasesMixin(object):
997
908
 
998
909
    def doMerge(self, base, a, b, mp):
1230
1141
        self._test_merge_from_strings(base, a, b, result)
1231
1142
 
1232
1143
 
1233
 
class TestWeaveMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
 
1144
class TestKnitMerge(TestCaseWithTransport, MergeCasesMixin):
 
1145
 
 
1146
    def get_file(self, name='foo'):
 
1147
        return KnitVersionedFile(name, get_transport(self.get_url('.')),
 
1148
                                 delta=True, create=True)
 
1149
 
 
1150
    def log_contents(self, w):
 
1151
        pass
 
1152
 
 
1153
 
 
1154
class TestWeaveMerge(TestCaseWithTransport, MergeCasesMixin):
1234
1155
 
1235
1156
    def get_file(self, name='foo'):
1236
1157
        return WeaveFile(name, get_transport(self.get_url('.')), create=True)
1243
1164
 
1244
1165
    overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======', 
1245
1166
                                'xxx', '>>>>>>> ', 'bbb']
1246
 
 
1247
 
 
1248
 
class TestContentFactoryAdaption(TestCaseWithMemoryTransport):
1249
 
 
1250
 
    def test_select_adaptor(self):
1251
 
        """Test expected adapters exist."""
1252
 
        # One scenario for each lookup combination we expect to use.
1253
 
        # Each is source_kind, requested_kind, adapter class
1254
 
        scenarios = [
1255
 
            ('knit-delta-gz', 'fulltext', _mod_knit.DeltaPlainToFullText),
1256
 
            ('knit-ft-gz', 'fulltext', _mod_knit.FTPlainToFullText),
1257
 
            ('knit-annotated-delta-gz', 'knit-delta-gz',
1258
 
                _mod_knit.DeltaAnnotatedToUnannotated),
1259
 
            ('knit-annotated-delta-gz', 'fulltext',
1260
 
                _mod_knit.DeltaAnnotatedToFullText),
1261
 
            ('knit-annotated-ft-gz', 'knit-ft-gz',
1262
 
                _mod_knit.FTAnnotatedToUnannotated),
1263
 
            ('knit-annotated-ft-gz', 'fulltext',
1264
 
                _mod_knit.FTAnnotatedToFullText),
1265
 
            ]
1266
 
        for source, requested, klass in scenarios:
1267
 
            adapter_factory = versionedfile.adapter_registry.get(
1268
 
                (source, requested))
1269
 
            adapter = adapter_factory(None)
1270
 
            self.assertIsInstance(adapter, klass)
1271
 
 
1272
 
    def get_knit(self, annotated=True):
1273
 
        mapper = ConstantMapper('knit')
1274
 
        transport = self.get_transport()
1275
 
        return make_file_factory(annotated, mapper)(transport)
1276
 
 
1277
 
    def helpGetBytes(self, f, ft_adapter, delta_adapter):
1278
 
        """Grab the interested adapted texts for tests."""
1279
 
        # origin is a fulltext
1280
 
        entries = f.get_record_stream([('origin',)], 'unordered', False)
1281
 
        base = entries.next()
1282
 
        ft_data = ft_adapter.get_bytes(base, base.get_bytes_as(base.storage_kind))
1283
 
        # merged is both a delta and multiple parents.
1284
 
        entries = f.get_record_stream([('merged',)], 'unordered', False)
1285
 
        merged = entries.next()
1286
 
        delta_data = delta_adapter.get_bytes(merged,
1287
 
            merged.get_bytes_as(merged.storage_kind))
1288
 
        return ft_data, delta_data
1289
 
 
1290
 
    def test_deannotation_noeol(self):
1291
 
        """Test converting annotated knits to unannotated knits."""
1292
 
        # we need a full text, and a delta
1293
 
        f = self.get_knit()
1294
 
        get_diamond_files(f, 1, trailing_eol=False)
1295
 
        ft_data, delta_data = self.helpGetBytes(f,
1296
 
            _mod_knit.FTAnnotatedToUnannotated(None),
1297
 
            _mod_knit.DeltaAnnotatedToUnannotated(None))
1298
 
        self.assertEqual(
1299
 
            'version origin 1 b284f94827db1fa2970d9e2014f080413b547a7e\n'
1300
 
            'origin\n'
1301
 
            'end origin\n',
1302
 
            GzipFile(mode='rb', fileobj=StringIO(ft_data)).read())
1303
 
        self.assertEqual(
1304
 
            'version merged 4 32c2e79763b3f90e8ccde37f9710b6629c25a796\n'
1305
 
            '1,2,3\nleft\nright\nmerged\nend merged\n',
1306
 
            GzipFile(mode='rb', fileobj=StringIO(delta_data)).read())
1307
 
 
1308
 
    def test_deannotation(self):
1309
 
        """Test converting annotated knits to unannotated knits."""
1310
 
        # we need a full text, and a delta
1311
 
        f = self.get_knit()
1312
 
        get_diamond_files(f, 1)
1313
 
        ft_data, delta_data = self.helpGetBytes(f,
1314
 
            _mod_knit.FTAnnotatedToUnannotated(None),
1315
 
            _mod_knit.DeltaAnnotatedToUnannotated(None))
1316
 
        self.assertEqual(
1317
 
            'version origin 1 00e364d235126be43292ab09cb4686cf703ddc17\n'
1318
 
            'origin\n'
1319
 
            'end origin\n',
1320
 
            GzipFile(mode='rb', fileobj=StringIO(ft_data)).read())
1321
 
        self.assertEqual(
1322
 
            'version merged 3 ed8bce375198ea62444dc71952b22cfc2b09226d\n'
1323
 
            '2,2,2\nright\nmerged\nend merged\n',
1324
 
            GzipFile(mode='rb', fileobj=StringIO(delta_data)).read())
1325
 
 
1326
 
    def test_annotated_to_fulltext_no_eol(self):
1327
 
        """Test adapting annotated knits to full texts (for -> weaves)."""
1328
 
        # we need a full text, and a delta
1329
 
        f = self.get_knit()
1330
 
        get_diamond_files(f, 1, trailing_eol=False)
1331
 
        # Reconstructing a full text requires a backing versioned file, and it
1332
 
        # must have the base lines requested from it.
1333
 
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
1334
 
        ft_data, delta_data = self.helpGetBytes(f,
1335
 
            _mod_knit.FTAnnotatedToFullText(None),
1336
 
            _mod_knit.DeltaAnnotatedToFullText(logged_vf))
1337
 
        self.assertEqual('origin', ft_data)
1338
 
        self.assertEqual('base\nleft\nright\nmerged', delta_data)
1339
 
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
1340
 
            True)], logged_vf.calls)
1341
 
 
1342
 
    def test_annotated_to_fulltext(self):
1343
 
        """Test adapting annotated knits to full texts (for -> weaves)."""
1344
 
        # we need a full text, and a delta
1345
 
        f = self.get_knit()
1346
 
        get_diamond_files(f, 1)
1347
 
        # Reconstructing a full text requires a backing versioned file, and it
1348
 
        # must have the base lines requested from it.
1349
 
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
1350
 
        ft_data, delta_data = self.helpGetBytes(f,
1351
 
            _mod_knit.FTAnnotatedToFullText(None),
1352
 
            _mod_knit.DeltaAnnotatedToFullText(logged_vf))
1353
 
        self.assertEqual('origin\n', ft_data)
1354
 
        self.assertEqual('base\nleft\nright\nmerged\n', delta_data)
1355
 
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
1356
 
            True)], logged_vf.calls)
1357
 
 
1358
 
    def test_unannotated_to_fulltext(self):
1359
 
        """Test adapting unannotated knits to full texts.
1360
 
        
1361
 
        This is used for -> weaves, and for -> annotated knits.
1362
 
        """
1363
 
        # we need a full text, and a delta
1364
 
        f = self.get_knit(annotated=False)
1365
 
        get_diamond_files(f, 1)
1366
 
        # Reconstructing a full text requires a backing versioned file, and it
1367
 
        # must have the base lines requested from it.
1368
 
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
1369
 
        ft_data, delta_data = self.helpGetBytes(f,
1370
 
            _mod_knit.FTPlainToFullText(None),
1371
 
            _mod_knit.DeltaPlainToFullText(logged_vf))
1372
 
        self.assertEqual('origin\n', ft_data)
1373
 
        self.assertEqual('base\nleft\nright\nmerged\n', delta_data)
1374
 
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
1375
 
            True)], logged_vf.calls)
1376
 
 
1377
 
    def test_unannotated_to_fulltext_no_eol(self):
1378
 
        """Test adapting unannotated knits to full texts.
1379
 
        
1380
 
        This is used for -> weaves, and for -> annotated knits.
1381
 
        """
1382
 
        # we need a full text, and a delta
1383
 
        f = self.get_knit(annotated=False)
1384
 
        get_diamond_files(f, 1, trailing_eol=False)
1385
 
        # Reconstructing a full text requires a backing versioned file, and it
1386
 
        # must have the base lines requested from it.
1387
 
        logged_vf = versionedfile.RecordingVersionedFilesDecorator(f)
1388
 
        ft_data, delta_data = self.helpGetBytes(f,
1389
 
            _mod_knit.FTPlainToFullText(None),
1390
 
            _mod_knit.DeltaPlainToFullText(logged_vf))
1391
 
        self.assertEqual('origin', ft_data)
1392
 
        self.assertEqual('base\nleft\nright\nmerged', delta_data)
1393
 
        self.assertEqual([('get_record_stream', [('left',)], 'unordered',
1394
 
            True)], logged_vf.calls)
1395
 
 
1396
 
 
1397
 
class TestKeyMapper(TestCaseWithMemoryTransport):
1398
 
    """Tests for various key mapping logic."""
1399
 
 
1400
 
    def test_identity_mapper(self):
1401
 
        mapper = versionedfile.ConstantMapper("inventory")
1402
 
        self.assertEqual("inventory", mapper.map(('foo@ar',)))
1403
 
        self.assertEqual("inventory", mapper.map(('quux',)))
1404
 
 
1405
 
    def test_prefix_mapper(self):
1406
 
        #format5: plain
1407
 
        mapper = versionedfile.PrefixMapper()
1408
 
        self.assertEqual("file-id", mapper.map(("file-id", "revision-id")))
1409
 
        self.assertEqual("new-id", mapper.map(("new-id", "revision-id")))
1410
 
        self.assertEqual(('file-id',), mapper.unmap("file-id"))
1411
 
        self.assertEqual(('new-id',), mapper.unmap("new-id"))
1412
 
 
1413
 
    def test_hash_prefix_mapper(self):
1414
 
        #format6: hash + plain
1415
 
        mapper = versionedfile.HashPrefixMapper()
1416
 
        self.assertEqual("9b/file-id", mapper.map(("file-id", "revision-id")))
1417
 
        self.assertEqual("45/new-id", mapper.map(("new-id", "revision-id")))
1418
 
        self.assertEqual(('file-id',), mapper.unmap("9b/file-id"))
1419
 
        self.assertEqual(('new-id',), mapper.unmap("45/new-id"))
1420
 
 
1421
 
    def test_hash_escaped_mapper(self):
1422
 
        #knit1: hash + escaped
1423
 
        mapper = versionedfile.HashEscapedPrefixMapper()
1424
 
        self.assertEqual("88/%2520", mapper.map((" ", "revision-id")))
1425
 
        self.assertEqual("ed/fil%2545-%2549d", mapper.map(("filE-Id",
1426
 
            "revision-id")))
1427
 
        self.assertEqual("88/ne%2557-%2549d", mapper.map(("neW-Id",
1428
 
            "revision-id")))
1429
 
        self.assertEqual(('filE-Id',), mapper.unmap("ed/fil%2545-%2549d"))
1430
 
        self.assertEqual(('neW-Id',), mapper.unmap("88/ne%2557-%2549d"))
1431
 
 
1432
 
 
1433
 
class TestVersionedFiles(TestCaseWithMemoryTransport):
1434
 
    """Tests for the multiple-file variant of VersionedFile."""
1435
 
 
1436
 
    def get_versionedfiles(self, relpath='files'):
1437
 
        transport = self.get_transport(relpath)
1438
 
        if relpath != '.':
1439
 
            transport.mkdir('.')
1440
 
        files = self.factory(transport)
1441
 
        if self.cleanup is not None:
1442
 
            self.addCleanup(lambda:self.cleanup(files))
1443
 
        return files
1444
 
 
1445
 
    def test_annotate(self):
1446
 
        files = self.get_versionedfiles()
1447
 
        self.get_diamond_files(files)
1448
 
        if self.key_length == 1:
1449
 
            prefix = ()
1450
 
        else:
1451
 
            prefix = ('FileA',)
1452
 
        # introduced full text
1453
 
        origins = files.annotate(prefix + ('origin',))
1454
 
        self.assertEqual([
1455
 
            (prefix + ('origin',), 'origin\n')],
1456
 
            origins)
1457
 
        # a delta
1458
 
        origins = files.annotate(prefix + ('base',))
1459
 
        self.assertEqual([
1460
 
            (prefix + ('base',), 'base\n')],
1461
 
            origins)
1462
 
        # a merge
1463
 
        origins = files.annotate(prefix + ('merged',))
1464
 
        if self.graph:
1465
 
            self.assertEqual([
1466
 
                (prefix + ('base',), 'base\n'),
1467
 
                (prefix + ('left',), 'left\n'),
1468
 
                (prefix + ('right',), 'right\n'),
1469
 
                (prefix + ('merged',), 'merged\n')
1470
 
                ],
1471
 
                origins)
1472
 
        else:
1473
 
            # Without a graph everything is new.
1474
 
            self.assertEqual([
1475
 
                (prefix + ('merged',), 'base\n'),
1476
 
                (prefix + ('merged',), 'left\n'),
1477
 
                (prefix + ('merged',), 'right\n'),
1478
 
                (prefix + ('merged',), 'merged\n')
1479
 
                ],
1480
 
                origins)
1481
 
        self.assertRaises(RevisionNotPresent,
1482
 
            files.annotate, prefix + ('missing-key',))
1483
 
 
1484
 
    def test_construct(self):
1485
 
        """Each parameterised test can be constructed on a transport."""
1486
 
        files = self.get_versionedfiles()
1487
 
 
1488
 
    def get_diamond_files(self, files, trailing_eol=True, left_only=False):
1489
 
        return get_diamond_files(files, self.key_length,
1490
 
            trailing_eol=trailing_eol, nograph=not self.graph,
1491
 
            left_only=left_only)
1492
 
 
1493
 
    def test_add_lines_return(self):
1494
 
        files = self.get_versionedfiles()
1495
 
        # save code by using the stock data insertion helper.
1496
 
        adds = self.get_diamond_files(files)
1497
 
        results = []
1498
 
        # We can only validate the first 2 elements returned from add_lines.
1499
 
        for add in adds:
1500
 
            self.assertEqual(3, len(add))
1501
 
            results.append(add[:2])
1502
 
        if self.key_length == 1:
1503
 
            self.assertEqual([
1504
 
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
1505
 
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
1506
 
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
1507
 
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
1508
 
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
1509
 
                results)
1510
 
        elif self.key_length == 2:
1511
 
            self.assertEqual([
1512
 
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
1513
 
                ('00e364d235126be43292ab09cb4686cf703ddc17', 7),
1514
 
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
1515
 
                ('51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44', 5),
1516
 
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
1517
 
                ('a8478686da38e370e32e42e8a0c220e33ee9132f', 10),
1518
 
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
1519
 
                ('9ef09dfa9d86780bdec9219a22560c6ece8e0ef1', 11),
1520
 
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23),
1521
 
                ('ed8bce375198ea62444dc71952b22cfc2b09226d', 23)],
1522
 
                results)
1523
 
 
1524
 
    def test_empty_lines(self):
1525
 
        """Empty files can be stored."""
1526
 
        f = self.get_versionedfiles()
1527
 
        key_a = self.get_simple_key('a')
1528
 
        f.add_lines(key_a, [], [])
1529
 
        self.assertEqual('',
1530
 
            f.get_record_stream([key_a], 'unordered', True
1531
 
                ).next().get_bytes_as('fulltext'))
1532
 
        key_b = self.get_simple_key('b')
1533
 
        f.add_lines(key_b, self.get_parents([key_a]), [])
1534
 
        self.assertEqual('',
1535
 
            f.get_record_stream([key_b], 'unordered', True
1536
 
                ).next().get_bytes_as('fulltext'))
1537
 
 
1538
 
    def test_newline_only(self):
1539
 
        f = self.get_versionedfiles()
1540
 
        key_a = self.get_simple_key('a')
1541
 
        f.add_lines(key_a, [], ['\n'])
1542
 
        self.assertEqual('\n',
1543
 
            f.get_record_stream([key_a], 'unordered', True
1544
 
                ).next().get_bytes_as('fulltext'))
1545
 
        key_b = self.get_simple_key('b')
1546
 
        f.add_lines(key_b, self.get_parents([key_a]), ['\n'])
1547
 
        self.assertEqual('\n',
1548
 
            f.get_record_stream([key_b], 'unordered', True
1549
 
                ).next().get_bytes_as('fulltext'))
1550
 
 
1551
 
    def test_get_record_stream_empty(self):
1552
 
        """An empty stream can be requested without error."""
1553
 
        f = self.get_versionedfiles()
1554
 
        entries = f.get_record_stream([], 'unordered', False)
1555
 
        self.assertEqual([], list(entries))
1556
 
 
1557
 
    def assertValidStorageKind(self, storage_kind):
1558
 
        """Assert that storage_kind is a valid storage_kind."""
1559
 
        self.assertSubset([storage_kind],
1560
 
            ['mpdiff', 'knit-annotated-ft', 'knit-annotated-delta',
1561
 
             'knit-ft', 'knit-delta', 'fulltext', 'knit-annotated-ft-gz',
1562
 
             'knit-annotated-delta-gz', 'knit-ft-gz', 'knit-delta-gz'])
1563
 
 
1564
 
    def capture_stream(self, f, entries, on_seen, parents):
1565
 
        """Capture a stream for testing."""
1566
 
        for factory in entries:
1567
 
            on_seen(factory.key)
1568
 
            self.assertValidStorageKind(factory.storage_kind)
1569
 
            self.assertEqual(f.get_sha1s([factory.key])[factory.key],
1570
 
                factory.sha1)
1571
 
            self.assertEqual(parents[factory.key], factory.parents)
1572
 
            self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
1573
 
                str)
1574
 
 
1575
 
    def test_get_record_stream_interface(self):
1576
 
        """each item in a stream has to provide a regular interface."""
1577
 
        files = self.get_versionedfiles()
1578
 
        self.get_diamond_files(files)
1579
 
        keys, _ = self.get_keys_and_sort_order()
1580
 
        parent_map = files.get_parent_map(keys)
1581
 
        entries = files.get_record_stream(keys, 'unordered', False)
1582
 
        seen = set()
1583
 
        self.capture_stream(files, entries, seen.add, parent_map)
1584
 
        self.assertEqual(set(keys), seen)
1585
 
 
1586
 
    def get_simple_key(self, suffix):
1587
 
        """Return a key for the object under test."""
1588
 
        if self.key_length == 1:
1589
 
            return (suffix,)
1590
 
        else:
1591
 
            return ('FileA',) + (suffix,)
1592
 
 
1593
 
    def get_keys_and_sort_order(self):
1594
 
        """Get diamond test keys list, and their sort ordering."""
1595
 
        if self.key_length == 1:
1596
 
            keys = [('merged',), ('left',), ('right',), ('base',)]
1597
 
            sort_order = {('merged',):2, ('left',):1, ('right',):1, ('base',):0}
1598
 
        else:
1599
 
            keys = [
1600
 
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
1601
 
                ('FileA', 'base'),
1602
 
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
1603
 
                ('FileB', 'base'),
1604
 
                ]
1605
 
            sort_order = {
1606
 
                ('FileA', 'merged'):2, ('FileA', 'left'):1, ('FileA', 'right'):1,
1607
 
                ('FileA', 'base'):0,
1608
 
                ('FileB', 'merged'):2, ('FileB', 'left'):1, ('FileB', 'right'):1,
1609
 
                ('FileB', 'base'):0,
1610
 
                }
1611
 
        return keys, sort_order
1612
 
 
1613
 
    def test_get_record_stream_interface_ordered(self):
1614
 
        """each item in a stream has to provide a regular interface."""
1615
 
        files = self.get_versionedfiles()
1616
 
        self.get_diamond_files(files)
1617
 
        keys, sort_order = self.get_keys_and_sort_order()
1618
 
        parent_map = files.get_parent_map(keys)
1619
 
        entries = files.get_record_stream(keys, 'topological', False)
1620
 
        seen = []
1621
 
        self.capture_stream(files, entries, seen.append, parent_map)
1622
 
        self.assertStreamOrder(sort_order, seen, keys)
1623
 
 
1624
 
    def test_get_record_stream_interface_ordered_with_delta_closure(self):
1625
 
        """each item must be accessible as a fulltext."""
1626
 
        files = self.get_versionedfiles()
1627
 
        self.get_diamond_files(files)
1628
 
        keys, sort_order = self.get_keys_and_sort_order()
1629
 
        parent_map = files.get_parent_map(keys)
1630
 
        entries = files.get_record_stream(keys, 'topological', True)
1631
 
        seen = []
1632
 
        for factory in entries:
1633
 
            seen.append(factory.key)
1634
 
            self.assertValidStorageKind(factory.storage_kind)
1635
 
            self.assertSubset([factory.sha1],
1636
 
                [None, files.get_sha1s([factory.key])[factory.key]])
1637
 
            self.assertEqual(parent_map[factory.key], factory.parents)
1638
 
            # self.assertEqual(files.get_text(factory.key),
1639
 
            self.assertIsInstance(factory.get_bytes_as('fulltext'), str)
1640
 
            self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
1641
 
                str)
1642
 
        self.assertStreamOrder(sort_order, seen, keys)
1643
 
 
1644
 
    def assertStreamOrder(self, sort_order, seen, keys):
1645
 
        self.assertEqual(len(set(seen)), len(keys))
1646
 
        if self.key_length == 1:
1647
 
            lows = {():0}
1648
 
        else:
1649
 
            lows = {('FileA',):0, ('FileB',):0}
1650
 
        if not self.graph:
1651
 
            self.assertEqual(set(keys), set(seen))
1652
 
        else:
1653
 
            for key in seen:
1654
 
                sort_pos = sort_order[key]
1655
 
                self.assertTrue(sort_pos >= lows[key[:-1]],
1656
 
                    "Out of order in sorted stream: %r, %r" % (key, seen))
1657
 
                lows[key[:-1]] = sort_pos
1658
 
 
1659
 
    def test_get_record_stream_unknown_storage_kind_raises(self):
1660
 
        """Asking for a storage kind that the stream cannot supply raises."""
1661
 
        files = self.get_versionedfiles()
1662
 
        self.get_diamond_files(files)
1663
 
        if self.key_length == 1:
1664
 
            keys = [('merged',), ('left',), ('right',), ('base',)]
1665
 
        else:
1666
 
            keys = [
1667
 
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
1668
 
                ('FileA', 'base'),
1669
 
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
1670
 
                ('FileB', 'base'),
1671
 
                ]
1672
 
        parent_map = files.get_parent_map(keys)
1673
 
        entries = files.get_record_stream(keys, 'unordered', False)
1674
 
        # We track the contents because we should be able to try, fail a
1675
 
        # particular kind and then ask for one that works and continue.
1676
 
        seen = set()
1677
 
        for factory in entries:
1678
 
            seen.add(factory.key)
1679
 
            self.assertValidStorageKind(factory.storage_kind)
1680
 
            self.assertEqual(files.get_sha1s([factory.key])[factory.key],
1681
 
                factory.sha1)
1682
 
            self.assertEqual(parent_map[factory.key], factory.parents)
1683
 
            # currently no stream emits mpdiff
1684
 
            self.assertRaises(errors.UnavailableRepresentation,
1685
 
                factory.get_bytes_as, 'mpdiff')
1686
 
            self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
1687
 
                str)
1688
 
        self.assertEqual(set(keys), seen)
1689
 
 
1690
 
    def test_get_record_stream_missing_records_are_absent(self):
1691
 
        files = self.get_versionedfiles()
1692
 
        self.get_diamond_files(files)
1693
 
        if self.key_length == 1:
1694
 
            keys = [('merged',), ('left',), ('right',), ('absent',), ('base',)]
1695
 
        else:
1696
 
            keys = [
1697
 
                ('FileA', 'merged'), ('FileA', 'left'), ('FileA', 'right'),
1698
 
                ('FileA', 'absent'), ('FileA', 'base'),
1699
 
                ('FileB', 'merged'), ('FileB', 'left'), ('FileB', 'right'),
1700
 
                ('FileB', 'absent'), ('FileB', 'base'),
1701
 
                ('absent', 'absent'),
1702
 
                ]
1703
 
        parent_map = files.get_parent_map(keys)
1704
 
        entries = files.get_record_stream(keys, 'unordered', False)
1705
 
        self.assertAbsentRecord(files, keys, parent_map, entries)
1706
 
        entries = files.get_record_stream(keys, 'topological', False)
1707
 
        self.assertAbsentRecord(files, keys, parent_map, entries)
1708
 
 
1709
 
    def assertAbsentRecord(self, files, keys, parents, entries):
1710
 
        """Helper for test_get_record_stream_missing_records_are_absent."""
1711
 
        seen = set()
1712
 
        for factory in entries:
1713
 
            seen.add(factory.key)
1714
 
            if factory.key[-1] == 'absent':
1715
 
                self.assertEqual('absent', factory.storage_kind)
1716
 
                self.assertEqual(None, factory.sha1)
1717
 
                self.assertEqual(None, factory.parents)
1718
 
            else:
1719
 
                self.assertValidStorageKind(factory.storage_kind)
1720
 
                self.assertEqual(files.get_sha1s([factory.key])[factory.key],
1721
 
                    factory.sha1)
1722
 
                self.assertEqual(parents[factory.key], factory.parents)
1723
 
                self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
1724
 
                    str)
1725
 
        self.assertEqual(set(keys), seen)
1726
 
 
1727
 
    def test_filter_absent_records(self):
1728
 
        """Requested missing records can be filter trivially."""
1729
 
        files = self.get_versionedfiles()
1730
 
        self.get_diamond_files(files)
1731
 
        keys, _ = self.get_keys_and_sort_order()
1732
 
        parent_map = files.get_parent_map(keys)
1733
 
        # Add an absent record in the middle of the present keys. (We don't ask
1734
 
        # for just absent keys to ensure that content before and after the
1735
 
        # absent keys is still delivered).
1736
 
        present_keys = list(keys)
1737
 
        if self.key_length == 1:
1738
 
            keys.insert(2, ('extra',))
1739
 
        else:
1740
 
            keys.insert(2, ('extra', 'extra'))
1741
 
        entries = files.get_record_stream(keys, 'unordered', False)
1742
 
        seen = set()
1743
 
        self.capture_stream(files, versionedfile.filter_absent(entries), seen.add,
1744
 
            parent_map)
1745
 
        self.assertEqual(set(present_keys), seen)
1746
 
 
1747
 
    def get_mapper(self):
1748
 
        """Get a mapper suitable for the key length of the test interface."""
1749
 
        if self.key_length == 1:
1750
 
            return ConstantMapper('source')
1751
 
        else:
1752
 
            return HashEscapedPrefixMapper()
1753
 
 
1754
 
    def get_parents(self, parents):
1755
 
        """Get parents, taking self.graph into consideration."""
1756
 
        if self.graph:
1757
 
            return parents
1758
 
        else:
1759
 
            return None
1760
 
 
1761
 
    def test_get_parent_map(self):
1762
 
        files = self.get_versionedfiles()
1763
 
        if self.key_length == 1:
1764
 
            parent_details = [
1765
 
                (('r0',), self.get_parents(())),
1766
 
                (('r1',), self.get_parents((('r0',),))),
1767
 
                (('r2',), self.get_parents(())),
1768
 
                (('r3',), self.get_parents(())),
1769
 
                (('m',), self.get_parents((('r0',),('r1',),('r2',),('r3',)))),
1770
 
                ]
1771
 
        else:
1772
 
            parent_details = [
1773
 
                (('FileA', 'r0'), self.get_parents(())),
1774
 
                (('FileA', 'r1'), self.get_parents((('FileA', 'r0'),))),
1775
 
                (('FileA', 'r2'), self.get_parents(())),
1776
 
                (('FileA', 'r3'), self.get_parents(())),
1777
 
                (('FileA', 'm'), self.get_parents((('FileA', 'r0'),
1778
 
                    ('FileA', 'r1'), ('FileA', 'r2'), ('FileA', 'r3')))),
1779
 
                ]
1780
 
        for key, parents in parent_details:
1781
 
            files.add_lines(key, parents, [])
1782
 
            # immediately after adding it should be queryable.
1783
 
            self.assertEqual({key:parents}, files.get_parent_map([key]))
1784
 
        # We can ask for an empty set
1785
 
        self.assertEqual({}, files.get_parent_map([]))
1786
 
        # We can ask for many keys
1787
 
        all_parents = dict(parent_details)
1788
 
        self.assertEqual(all_parents, files.get_parent_map(all_parents.keys()))
1789
 
        # Absent keys are just not included in the result.
1790
 
        keys = all_parents.keys()
1791
 
        if self.key_length == 1:
1792
 
            keys.insert(1, ('missing',))
1793
 
        else:
1794
 
            keys.insert(1, ('missing', 'missing'))
1795
 
        # Absent keys are just ignored
1796
 
        self.assertEqual(all_parents, files.get_parent_map(keys))
1797
 
 
1798
 
    def test_get_sha1s(self):
1799
 
        files = self.get_versionedfiles()
1800
 
        self.get_diamond_files(files)
1801
 
        if self.key_length == 1:
1802
 
            keys = [('base',), ('origin',), ('left',), ('merged',), ('right',)]
1803
 
        else:
1804
 
            # ask for shas from different prefixes.
1805
 
            keys = [
1806
 
                ('FileA', 'base'), ('FileB', 'origin'), ('FileA', 'left'),
1807
 
                ('FileA', 'merged'), ('FileB', 'right'),
1808
 
                ]
1809
 
        self.assertEqual({
1810
 
            keys[0]: '51c64a6f4fc375daf0d24aafbabe4d91b6f4bb44',
1811
 
            keys[1]: '00e364d235126be43292ab09cb4686cf703ddc17',
1812
 
            keys[2]: 'a8478686da38e370e32e42e8a0c220e33ee9132f',
1813
 
            keys[3]: 'ed8bce375198ea62444dc71952b22cfc2b09226d',
1814
 
            keys[4]: '9ef09dfa9d86780bdec9219a22560c6ece8e0ef1',
1815
 
            },
1816
 
            files.get_sha1s(keys))
1817
 
        
1818
 
    def test_insert_record_stream_empty(self):
1819
 
        """Inserting an empty record stream should work."""
1820
 
        files = self.get_versionedfiles()
1821
 
        files.insert_record_stream([])
1822
 
 
1823
 
    def assertIdenticalVersionedFile(self, expected, actual):
1824
 
        """Assert that left and right have the same contents."""
1825
 
        self.assertEqual(set(actual.keys()), set(expected.keys()))
1826
 
        actual_parents = actual.get_parent_map(actual.keys())
1827
 
        if self.graph:
1828
 
            self.assertEqual(actual_parents, expected.get_parent_map(expected.keys()))
1829
 
        else:
1830
 
            for key, parents in actual_parents.items():
1831
 
                self.assertEqual(None, parents)
1832
 
        for key in actual.keys():
1833
 
            actual_text = actual.get_record_stream(
1834
 
                [key], 'unordered', True).next().get_bytes_as('fulltext')
1835
 
            expected_text = expected.get_record_stream(
1836
 
                [key], 'unordered', True).next().get_bytes_as('fulltext')
1837
 
            self.assertEqual(actual_text, expected_text)
1838
 
 
1839
 
    def test_insert_record_stream_fulltexts(self):
1840
 
        """Any file should accept a stream of fulltexts."""
1841
 
        files = self.get_versionedfiles()
1842
 
        mapper = self.get_mapper()
1843
 
        source_transport = self.get_transport('source')
1844
 
        source_transport.mkdir('.')
1845
 
        # weaves always output fulltexts.
1846
 
        source = make_versioned_files_factory(WeaveFile, mapper)(
1847
 
            source_transport)
1848
 
        self.get_diamond_files(source, trailing_eol=False)
1849
 
        stream = source.get_record_stream(source.keys(), 'topological',
1850
 
            False)
1851
 
        files.insert_record_stream(stream)
1852
 
        self.assertIdenticalVersionedFile(source, files)
1853
 
 
1854
 
    def test_insert_record_stream_fulltexts_noeol(self):
1855
 
        """Any file should accept a stream of fulltexts."""
1856
 
        files = self.get_versionedfiles()
1857
 
        mapper = self.get_mapper()
1858
 
        source_transport = self.get_transport('source')
1859
 
        source_transport.mkdir('.')
1860
 
        # weaves always output fulltexts.
1861
 
        source = make_versioned_files_factory(WeaveFile, mapper)(
1862
 
            source_transport)
1863
 
        self.get_diamond_files(source, trailing_eol=False)
1864
 
        stream = source.get_record_stream(source.keys(), 'topological',
1865
 
            False)
1866
 
        files.insert_record_stream(stream)
1867
 
        self.assertIdenticalVersionedFile(source, files)
1868
 
 
1869
 
    def test_insert_record_stream_annotated_knits(self):
1870
 
        """Any file should accept a stream from plain knits."""
1871
 
        files = self.get_versionedfiles()
1872
 
        mapper = self.get_mapper()
1873
 
        source_transport = self.get_transport('source')
1874
 
        source_transport.mkdir('.')
1875
 
        source = make_file_factory(True, mapper)(source_transport)
1876
 
        self.get_diamond_files(source)
1877
 
        stream = source.get_record_stream(source.keys(), 'topological',
1878
 
            False)
1879
 
        files.insert_record_stream(stream)
1880
 
        self.assertIdenticalVersionedFile(source, files)
1881
 
 
1882
 
    def test_insert_record_stream_annotated_knits_noeol(self):
1883
 
        """Any file should accept a stream from plain knits."""
1884
 
        files = self.get_versionedfiles()
1885
 
        mapper = self.get_mapper()
1886
 
        source_transport = self.get_transport('source')
1887
 
        source_transport.mkdir('.')
1888
 
        source = make_file_factory(True, mapper)(source_transport)
1889
 
        self.get_diamond_files(source, trailing_eol=False)
1890
 
        stream = source.get_record_stream(source.keys(), 'topological',
1891
 
            False)
1892
 
        files.insert_record_stream(stream)
1893
 
        self.assertIdenticalVersionedFile(source, files)
1894
 
 
1895
 
    def test_insert_record_stream_plain_knits(self):
1896
 
        """Any file should accept a stream from plain knits."""
1897
 
        files = self.get_versionedfiles()
1898
 
        mapper = self.get_mapper()
1899
 
        source_transport = self.get_transport('source')
1900
 
        source_transport.mkdir('.')
1901
 
        source = make_file_factory(False, mapper)(source_transport)
1902
 
        self.get_diamond_files(source)
1903
 
        stream = source.get_record_stream(source.keys(), 'topological',
1904
 
            False)
1905
 
        files.insert_record_stream(stream)
1906
 
        self.assertIdenticalVersionedFile(source, files)
1907
 
 
1908
 
    def test_insert_record_stream_plain_knits_noeol(self):
1909
 
        """Any file should accept a stream from plain knits."""
1910
 
        files = self.get_versionedfiles()
1911
 
        mapper = self.get_mapper()
1912
 
        source_transport = self.get_transport('source')
1913
 
        source_transport.mkdir('.')
1914
 
        source = make_file_factory(False, mapper)(source_transport)
1915
 
        self.get_diamond_files(source, trailing_eol=False)
1916
 
        stream = source.get_record_stream(source.keys(), 'topological',
1917
 
            False)
1918
 
        files.insert_record_stream(stream)
1919
 
        self.assertIdenticalVersionedFile(source, files)
1920
 
 
1921
 
    def test_insert_record_stream_existing_keys(self):
1922
 
        """Inserting keys already in a file should not error."""
1923
 
        files = self.get_versionedfiles()
1924
 
        source = self.get_versionedfiles('source')
1925
 
        self.get_diamond_files(source)
1926
 
        # insert some keys into f.
1927
 
        self.get_diamond_files(files, left_only=True)
1928
 
        stream = source.get_record_stream(source.keys(), 'topological',
1929
 
            False)
1930
 
        files.insert_record_stream(stream)
1931
 
        self.assertIdenticalVersionedFile(source, files)
1932
 
 
1933
 
    def test_insert_record_stream_missing_keys(self):
1934
 
        """Inserting a stream with absent keys should raise an error."""
1935
 
        files = self.get_versionedfiles()
1936
 
        source = self.get_versionedfiles('source')
1937
 
        stream = source.get_record_stream([('missing',) * self.key_length],
1938
 
            'topological', False)
1939
 
        self.assertRaises(errors.RevisionNotPresent, files.insert_record_stream,
1940
 
            stream)
1941
 
 
1942
 
    def test_insert_record_stream_out_of_order(self):
1943
 
        """An out of order stream can either error or work."""
1944
 
        files = self.get_versionedfiles()
1945
 
        source = self.get_versionedfiles('source')
1946
 
        self.get_diamond_files(source)
1947
 
        if self.key_length == 1:
1948
 
            origin_keys = [('origin',)]
1949
 
            end_keys = [('merged',), ('left',)]
1950
 
            start_keys = [('right',), ('base',)]
1951
 
        else:
1952
 
            origin_keys = [('FileA', 'origin'), ('FileB', 'origin')]
1953
 
            end_keys = [('FileA', 'merged',), ('FileA', 'left',),
1954
 
                ('FileB', 'merged',), ('FileB', 'left',)]
1955
 
            start_keys = [('FileA', 'right',), ('FileA', 'base',),
1956
 
                ('FileB', 'right',), ('FileB', 'base',)]
1957
 
        origin_entries = source.get_record_stream(origin_keys, 'unordered', False)
1958
 
        end_entries = source.get_record_stream(end_keys, 'topological', False)
1959
 
        start_entries = source.get_record_stream(start_keys, 'topological', False)
1960
 
        entries = chain(origin_entries, end_entries, start_entries)
1961
 
        try:
1962
 
            files.insert_record_stream(entries)
1963
 
        except RevisionNotPresent:
1964
 
            # Must not have corrupted the file.
1965
 
            files.check()
1966
 
        else:
1967
 
            self.assertIdenticalVersionedFile(source, files)
1968
 
 
1969
 
    def test_insert_record_stream_delta_missing_basis_no_corruption(self):
1970
 
        """Insertion where a needed basis is not included aborts safely."""
1971
 
        # We use a knit always here to be sure we are getting a binary delta.
1972
 
        mapper = self.get_mapper()
1973
 
        source_transport = self.get_transport('source')
1974
 
        source_transport.mkdir('.')
1975
 
        source = make_file_factory(False, mapper)(source_transport)
1976
 
        self.get_diamond_files(source)
1977
 
        entries = source.get_record_stream(['origin', 'merged'], 'unordered', False)
1978
 
        files = self.get_versionedfiles()
1979
 
        self.assertRaises(RevisionNotPresent, files.insert_record_stream,
1980
 
            entries)
1981
 
        files.check()
1982
 
        self.assertEqual({}, files.get_parent_map([]))
1983
 
 
1984
 
    def test_iter_lines_added_or_present_in_keys(self):
1985
 
        # test that we get at least an equalset of the lines added by
1986
 
        # versions in the store.
1987
 
        # the ordering here is to make a tree so that dumb searches have
1988
 
        # more changes to muck up.
1989
 
 
1990
 
        class InstrumentedProgress(progress.DummyProgress):
1991
 
 
1992
 
            def __init__(self):
1993
 
 
1994
 
                progress.DummyProgress.__init__(self)
1995
 
                self.updates = []
1996
 
 
1997
 
            def update(self, msg=None, current=None, total=None):
1998
 
                self.updates.append((msg, current, total))
1999
 
 
2000
 
        files = self.get_versionedfiles()
2001
 
        # add a base to get included
2002
 
        files.add_lines(self.get_simple_key('base'), (), ['base\n'])
2003
 
        # add a ancestor to be included on one side
2004
 
        files.add_lines(self.get_simple_key('lancestor'), (), ['lancestor\n'])
2005
 
        # add a ancestor to be included on the other side
2006
 
        files.add_lines(self.get_simple_key('rancestor'),
2007
 
            self.get_parents([self.get_simple_key('base')]), ['rancestor\n'])
2008
 
        # add a child of rancestor with no eofile-nl
2009
 
        files.add_lines(self.get_simple_key('child'),
2010
 
            self.get_parents([self.get_simple_key('rancestor')]),
2011
 
            ['base\n', 'child\n'])
2012
 
        # add a child of lancestor and base to join the two roots
2013
 
        files.add_lines(self.get_simple_key('otherchild'),
2014
 
            self.get_parents([self.get_simple_key('lancestor'),
2015
 
                self.get_simple_key('base')]),
2016
 
            ['base\n', 'lancestor\n', 'otherchild\n'])
2017
 
        def iter_with_keys(keys, expected):
2018
 
            # now we need to see what lines are returned, and how often.
2019
 
            lines = {}
2020
 
            progress = InstrumentedProgress()
2021
 
            # iterate over the lines
2022
 
            for line in files.iter_lines_added_or_present_in_keys(keys,
2023
 
                pb=progress):
2024
 
                lines.setdefault(line, 0)
2025
 
                lines[line] += 1
2026
 
            if []!= progress.updates:
2027
 
                self.assertEqual(expected, progress.updates)
2028
 
            return lines
2029
 
        lines = iter_with_keys(
2030
 
            [self.get_simple_key('child'), self.get_simple_key('otherchild')],
2031
 
            [('Walking content.', 0, 2),
2032
 
             ('Walking content.', 1, 2),
2033
 
             ('Walking content.', 2, 2)])
2034
 
        # we must see child and otherchild
2035
 
        self.assertTrue(lines[('child\n', self.get_simple_key('child'))] > 0)
2036
 
        self.assertTrue(
2037
 
            lines[('otherchild\n', self.get_simple_key('otherchild'))] > 0)
2038
 
        # we dont care if we got more than that.
2039
 
        
2040
 
        # test all lines
2041
 
        lines = iter_with_keys(files.keys(),
2042
 
            [('Walking content.', 0, 5),
2043
 
             ('Walking content.', 1, 5),
2044
 
             ('Walking content.', 2, 5),
2045
 
             ('Walking content.', 3, 5),
2046
 
             ('Walking content.', 4, 5),
2047
 
             ('Walking content.', 5, 5)])
2048
 
        # all lines must be seen at least once
2049
 
        self.assertTrue(lines[('base\n', self.get_simple_key('base'))] > 0)
2050
 
        self.assertTrue(
2051
 
            lines[('lancestor\n', self.get_simple_key('lancestor'))] > 0)
2052
 
        self.assertTrue(
2053
 
            lines[('rancestor\n', self.get_simple_key('rancestor'))] > 0)
2054
 
        self.assertTrue(lines[('child\n', self.get_simple_key('child'))] > 0)
2055
 
        self.assertTrue(
2056
 
            lines[('otherchild\n', self.get_simple_key('otherchild'))] > 0)
2057
 
 
2058
 
    def test_make_mpdiffs(self):
2059
 
        from bzrlib import multiparent
2060
 
        files = self.get_versionedfiles('source')
2061
 
        # add texts that should trip the knit maximum delta chain threshold
2062
 
        # as well as doing parallel chains of data in knits.
2063
 
        # this is done by two chains of 25 insertions
2064
 
        files.add_lines(self.get_simple_key('base'), [], ['line\n'])
2065
 
        files.add_lines(self.get_simple_key('noeol'),
2066
 
            self.get_parents([self.get_simple_key('base')]), ['line'])
2067
 
        # detailed eol tests:
2068
 
        # shared last line with parent no-eol
2069
 
        files.add_lines(self.get_simple_key('noeolsecond'),
2070
 
            self.get_parents([self.get_simple_key('noeol')]),
2071
 
                ['line\n', 'line'])
2072
 
        # differing last line with parent, both no-eol
2073
 
        files.add_lines(self.get_simple_key('noeolnotshared'),
2074
 
            self.get_parents([self.get_simple_key('noeolsecond')]),
2075
 
                ['line\n', 'phone'])
2076
 
        # add eol following a noneol parent, change content
2077
 
        files.add_lines(self.get_simple_key('eol'),
2078
 
            self.get_parents([self.get_simple_key('noeol')]), ['phone\n'])
2079
 
        # add eol following a noneol parent, no change content
2080
 
        files.add_lines(self.get_simple_key('eolline'),
2081
 
            self.get_parents([self.get_simple_key('noeol')]), ['line\n'])
2082
 
        # noeol with no parents:
2083
 
        files.add_lines(self.get_simple_key('noeolbase'), [], ['line'])
2084
 
        # noeol preceeding its leftmost parent in the output:
2085
 
        # this is done by making it a merge of two parents with no common
2086
 
        # anestry: noeolbase and noeol with the 
2087
 
        # later-inserted parent the leftmost.
2088
 
        files.add_lines(self.get_simple_key('eolbeforefirstparent'),
2089
 
            self.get_parents([self.get_simple_key('noeolbase'),
2090
 
                self.get_simple_key('noeol')]),
2091
 
            ['line'])
2092
 
        # two identical eol texts
2093
 
        files.add_lines(self.get_simple_key('noeoldup'),
2094
 
            self.get_parents([self.get_simple_key('noeol')]), ['line'])
2095
 
        next_parent = self.get_simple_key('base')
2096
 
        text_name = 'chain1-'
2097
 
        text = ['line\n']
2098
 
        sha1s = {0 :'da6d3141cb4a5e6f464bf6e0518042ddc7bfd079',
2099
 
                 1 :'45e21ea146a81ea44a821737acdb4f9791c8abe7',
2100
 
                 2 :'e1f11570edf3e2a070052366c582837a4fe4e9fa',
2101
 
                 3 :'26b4b8626da827088c514b8f9bbe4ebf181edda1',
2102
 
                 4 :'e28a5510be25ba84d31121cff00956f9970ae6f6',
2103
 
                 5 :'d63ec0ce22e11dcf65a931b69255d3ac747a318d',
2104
 
                 6 :'2c2888d288cb5e1d98009d822fedfe6019c6a4ea',
2105
 
                 7 :'95c14da9cafbf828e3e74a6f016d87926ba234ab',
2106
 
                 8 :'779e9a0b28f9f832528d4b21e17e168c67697272',
2107
 
                 9 :'1f8ff4e5c6ff78ac106fcfe6b1e8cb8740ff9a8f',
2108
 
                 10:'131a2ae712cf51ed62f143e3fbac3d4206c25a05',
2109
 
                 11:'c5a9d6f520d2515e1ec401a8f8a67e6c3c89f199',
2110
 
                 12:'31a2286267f24d8bedaa43355f8ad7129509ea85',
2111
 
                 13:'dc2a7fe80e8ec5cae920973973a8ee28b2da5e0a',
2112
 
                 14:'2c4b1736566b8ca6051e668de68650686a3922f2',
2113
 
                 15:'5912e4ecd9b0c07be4d013e7e2bdcf9323276cde',
2114
 
                 16:'b0d2e18d3559a00580f6b49804c23fea500feab3',
2115
 
                 17:'8e1d43ad72f7562d7cb8f57ee584e20eb1a69fc7',
2116
 
                 18:'5cf64a3459ae28efa60239e44b20312d25b253f3',
2117
 
                 19:'1ebed371807ba5935958ad0884595126e8c4e823',
2118
 
                 20:'2aa62a8b06fb3b3b892a3292a068ade69d5ee0d3',
2119
 
                 21:'01edc447978004f6e4e962b417a4ae1955b6fe5d',
2120
 
                 22:'d8d8dc49c4bf0bab401e0298bb5ad827768618bb',
2121
 
                 23:'c21f62b1c482862983a8ffb2b0c64b3451876e3f',
2122
 
                 24:'c0593fe795e00dff6b3c0fe857a074364d5f04fc',
2123
 
                 25:'dd1a1cf2ba9cc225c3aff729953e6364bf1d1855',
2124
 
                 }
2125
 
        for depth in range(26):
2126
 
            new_version = self.get_simple_key(text_name + '%s' % depth)
2127
 
            text = text + ['line\n']
2128
 
            files.add_lines(new_version, self.get_parents([next_parent]), text)
2129
 
            next_parent = new_version
2130
 
        next_parent = self.get_simple_key('base')
2131
 
        text_name = 'chain2-'
2132
 
        text = ['line\n']
2133
 
        for depth in range(26):
2134
 
            new_version = self.get_simple_key(text_name + '%s' % depth)
2135
 
            text = text + ['line\n']
2136
 
            files.add_lines(new_version, self.get_parents([next_parent]), text)
2137
 
            next_parent = new_version
2138
 
        target = self.get_versionedfiles('target')
2139
 
        for key in multiparent.topo_iter_keys(files, files.keys()):
2140
 
            mpdiff = files.make_mpdiffs([key])[0]
2141
 
            parents = files.get_parent_map([key])[key] or []
2142
 
            target.add_mpdiffs(
2143
 
                [(key, parents, files.get_sha1s([key])[key], mpdiff)])
2144
 
            self.assertEqualDiff(
2145
 
                files.get_record_stream([key], 'unordered',
2146
 
                    True).next().get_bytes_as('fulltext'),
2147
 
                target.get_record_stream([key], 'unordered',
2148
 
                    True).next().get_bytes_as('fulltext')
2149
 
                )
2150
 
 
2151
 
    def test_keys(self):
2152
 
        # While use is discouraged, versions() is still needed by aspects of
2153
 
        # bzr.
2154
 
        files = self.get_versionedfiles()
2155
 
        self.assertEqual(set(), set(files.keys()))
2156
 
        if self.key_length == 1:
2157
 
            key = ('foo',)
2158
 
        else:
2159
 
            key = ('foo', 'bar',)
2160
 
        files.add_lines(key, (), [])
2161
 
        self.assertEqual(set([key]), set(files.keys()))
2162
 
 
2163
 
 
2164
 
class VirtualVersionedFilesTests(TestCase):
2165
 
    """Basic tests for the VirtualVersionedFiles implementations."""
2166
 
 
2167
 
    def _get_parent_map(self, keys):
2168
 
        ret = {}
2169
 
        for k in keys:
2170
 
            if k in self._parent_map:
2171
 
                ret[k] = self._parent_map[k]
2172
 
        return ret
2173
 
 
2174
 
    def setUp(self):
2175
 
        TestCase.setUp(self)
2176
 
        self._lines = {}
2177
 
        self._parent_map = {}
2178
 
        self.texts = VirtualVersionedFiles(self._get_parent_map, 
2179
 
                                           self._lines.get)
2180
 
 
2181
 
    def test_add_lines(self):
2182
 
        self.assertRaises(NotImplementedError, 
2183
 
                self.texts.add_lines, "foo", [], [])
2184
 
 
2185
 
    def test_add_mpdiffs(self):
2186
 
        self.assertRaises(NotImplementedError, 
2187
 
                self.texts.add_mpdiffs, [])
2188
 
 
2189
 
    def test_check(self):
2190
 
        self.assertTrue(self.texts.check())
2191
 
 
2192
 
    def test_insert_record_stream(self):
2193
 
        self.assertRaises(NotImplementedError, self.texts.insert_record_stream,
2194
 
                          [])
2195
 
 
2196
 
    def test_get_sha1s_nonexistent(self):
2197
 
        self.assertEquals({}, self.texts.get_sha1s([("NONEXISTENT",)]))
2198
 
 
2199
 
    def test_get_sha1s(self):
2200
 
        self._lines["key"] = ["dataline1", "dataline2"]
2201
 
        self.assertEquals({("key",): osutils.sha_strings(self._lines["key"])},
2202
 
                           self.texts.get_sha1s([("key",)]))
2203
 
 
2204
 
    def test_get_parent_map(self):
2205
 
        self._parent_map = {"G": ("A", "B")}
2206
 
        self.assertEquals({("G",): (("A",),("B",))}, 
2207
 
                          self.texts.get_parent_map([("G",), ("L",)]))
2208
 
 
2209
 
    def test_get_record_stream(self):
2210
 
        self._lines["A"] = ["FOO", "BAR"]
2211
 
        it = self.texts.get_record_stream([("A",)], "unordered", True)
2212
 
        record = it.next()
2213
 
        self.assertEquals("fulltext", record.storage_kind)
2214
 
        self.assertEquals("FOOBAR", record.get_bytes_as("fulltext"))
2215
 
 
2216
 
    def test_get_record_stream_absent(self):
2217
 
        it = self.texts.get_record_stream([("A",)], "unordered", True)
2218
 
        record = it.next()
2219
 
        self.assertEquals("absent", record.storage_kind)
2220