1
# Copyright (C) 2005 Canonical Ltd
4
# Johan Rydberg <jrydberg@gnu.org>
6
# This program is free software; you can redistribute it and/or modify
7
# it under the terms of the GNU General Public License as published by
8
# the Free Software Foundation; either version 2 of the License, or
9
# (at your option) any later version.
11
# This program is distributed in the hope that it will be useful,
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
# GNU General Public License for more details.
16
# You should have received a copy of the GNU General Public License
17
# along with this program; if not, write to the Free Software
18
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
# TODO: might be nice to create a versionedfile with some type of corruption
22
# considered typical and check that it can be detected/corrected.
24
from itertools import chain
25
from StringIO import StringIO
33
from bzrlib.errors import (
35
RevisionAlreadyPresent,
38
from bzrlib import knit as _mod_knit
39
from bzrlib.knit import (
44
from bzrlib.symbol_versioning import one_four, one_five
45
from bzrlib.tests import TestCaseWithMemoryTransport, TestSkipped
46
from bzrlib.tests.http_utils import TestCaseWithWebserver
47
from bzrlib.trace import mutter
48
from bzrlib.transport import get_transport
49
from bzrlib.transport.memory import MemoryTransport
50
from bzrlib.tsort import topo_sort
51
from bzrlib.tuned_gzip import GzipFile
52
import bzrlib.versionedfile as versionedfile
53
from bzrlib.weave import WeaveFile
54
from bzrlib.weavefile import read_weave, write_weave
57
def get_diamond_vf(f, trailing_eol=True, left_only=False):
58
"""Get a diamond graph to exercise deltas and merges.
60
:param trailing_eol: If True end the last line with \n.
64
'base': (('origin',),),
66
'right': (('base',),),
67
'merged': (('left',), ('right',)),
69
# insert a diamond graph to exercise deltas and merges.
74
f.add_lines('origin', [], ['origin' + last_char])
75
f.add_lines('base', ['origin'], ['base' + last_char])
76
f.add_lines('left', ['base'], ['base\n', 'left' + last_char])
78
f.add_lines('right', ['base'],
79
['base\n', 'right' + last_char])
80
f.add_lines('merged', ['left', 'right'],
81
['base\n', 'left\n', 'right\n', 'merged' + last_char])
85
class VersionedFileTestMixIn(object):
86
"""A mixin test class for testing VersionedFiles.
88
This is not an adaptor-style test at this point because
89
theres no dynamic substitution of versioned file implementations,
90
they are strictly controlled by their owning repositories.
93
def get_transaction(self):
94
if not hasattr(self, '_transaction'):
95
self._transaction = None
96
return self._transaction
100
f.add_lines('r0', [], ['a\n', 'b\n'])
101
f.add_lines('r1', ['r0'], ['b\n', 'c\n'])
103
versions = f.versions()
104
self.assertTrue('r0' in versions)
105
self.assertTrue('r1' in versions)
106
self.assertEquals(f.get_lines('r0'), ['a\n', 'b\n'])
107
self.assertEquals(f.get_text('r0'), 'a\nb\n')
108
self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
109
self.assertEqual(2, len(f))
110
self.assertEqual(2, f.num_versions())
112
self.assertRaises(RevisionNotPresent,
113
f.add_lines, 'r2', ['foo'], [])
114
self.assertRaises(RevisionAlreadyPresent,
115
f.add_lines, 'r1', [], [])
117
# this checks that reopen with create=True does not break anything.
118
f = self.reopen_file(create=True)
121
def test_get_record_stream_empty(self):
122
"""get_record_stream is a replacement for get_data_stream."""
124
entries = f.get_record_stream([], 'unordered', False)
125
self.assertEqual([], list(entries))
127
def assertValidStorageKind(self, storage_kind):
128
"""Assert that storage_kind is a valid storage_kind."""
129
self.assertSubset([storage_kind],
130
['mpdiff', 'knit-annotated-ft', 'knit-annotated-delta',
131
'knit-ft', 'knit-delta', 'fulltext', 'knit-annotated-ft-gz',
132
'knit-annotated-delta-gz', 'knit-ft-gz', 'knit-delta-gz'])
134
def capture_stream(self, f, entries, on_seen, parents):
135
"""Capture a stream for testing."""
136
for factory in entries:
138
self.assertValidStorageKind(factory.storage_kind)
139
self.assertEqual(f.get_sha1s([factory.key[0]])[0], factory.sha1)
140
self.assertEqual(parents[factory.key[0]], factory.parents)
141
self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
144
def test_get_record_stream_interface(self):
145
"""Each item in a stream has to provide a regular interface."""
146
f, parents = get_diamond_vf(self.get_file())
147
entries = f.get_record_stream(['merged', 'left', 'right', 'base'],
150
self.capture_stream(f, entries, seen.add, parents)
151
self.assertEqual(set([('base',), ('left',), ('right',), ('merged',)]),
154
def test_get_record_stream_interface_ordered(self):
155
"""Each item in a stream has to provide a regular interface."""
156
f, parents = get_diamond_vf(self.get_file())
157
entries = f.get_record_stream(['merged', 'left', 'right', 'base'],
158
'topological', False)
160
self.capture_stream(f, entries, seen.append, parents)
161
self.assertSubset([tuple(seen)],
163
(('base',), ('left',), ('right',), ('merged',)),
164
(('base',), ('right',), ('left',), ('merged',)),
167
def test_get_record_stream_interface_ordered_with_delta_closure(self):
168
"""Each item in a stream has to provide a regular interface."""
169
f, parents = get_diamond_vf(self.get_file())
170
entries = f.get_record_stream(['merged', 'left', 'right', 'base'],
173
for factory in entries:
174
seen.append(factory.key)
175
self.assertValidStorageKind(factory.storage_kind)
176
self.assertEqual(f.get_sha1s([factory.key[0]])[0], factory.sha1)
177
self.assertEqual(parents[factory.key[0]], factory.parents)
178
self.assertEqual(f.get_text(factory.key[0]),
179
factory.get_bytes_as('fulltext'))
180
self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
182
self.assertSubset([tuple(seen)],
184
(('base',), ('left',), ('right',), ('merged',)),
185
(('base',), ('right',), ('left',), ('merged',)),
188
def test_get_record_stream_unknown_storage_kind_raises(self):
189
"""Asking for a storage kind that the stream cannot supply raises."""
190
f, parents = get_diamond_vf(self.get_file())
191
entries = f.get_record_stream(['merged', 'left', 'right', 'base'],
193
# We track the contents because we should be able to try, fail a
194
# particular kind and then ask for one that works and continue.
196
for factory in entries:
197
seen.add(factory.key)
198
self.assertValidStorageKind(factory.storage_kind)
199
self.assertEqual(f.get_sha1s([factory.key[0]])[0], factory.sha1)
200
self.assertEqual(parents[factory.key[0]], factory.parents)
201
# currently no stream emits mpdiff
202
self.assertRaises(errors.UnavailableRepresentation,
203
factory.get_bytes_as, 'mpdiff')
204
self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
206
self.assertEqual(set([('base',), ('left',), ('right',), ('merged',)]),
209
def test_get_record_stream_missing_records_are_absent(self):
210
f, parents = get_diamond_vf(self.get_file())
211
entries = f.get_record_stream(['merged', 'left', 'right', 'or', 'base'],
213
self.assertAbsentRecord(f, parents, entries)
214
entries = f.get_record_stream(['merged', 'left', 'right', 'or', 'base'],
215
'topological', False)
216
self.assertAbsentRecord(f, parents, entries)
218
def assertAbsentRecord(self, f, parents, entries):
219
"""Helper for test_get_record_stream_missing_records_are_absent."""
221
for factory in entries:
222
seen.add(factory.key)
223
if factory.key == ('or',):
224
self.assertEqual('absent', factory.storage_kind)
225
self.assertEqual(None, factory.sha1)
226
self.assertEqual(None, factory.parents)
228
self.assertValidStorageKind(factory.storage_kind)
229
self.assertEqual(f.get_sha1s([factory.key[0]])[0], factory.sha1)
230
self.assertEqual(parents[factory.key[0]], factory.parents)
231
self.assertIsInstance(factory.get_bytes_as(factory.storage_kind),
234
set([('base',), ('left',), ('right',), ('merged',), ('or',)]),
237
def test_filter_absent_records(self):
238
"""Requested missing records can be filter trivially."""
239
f, parents = get_diamond_vf(self.get_file())
240
entries = f.get_record_stream(['merged', 'left', 'right', 'extra', 'base'],
243
self.capture_stream(f, versionedfile.filter_absent(entries), seen.add,
245
self.assertEqual(set([('base',), ('left',), ('right',), ('merged',)]),
248
def test_insert_record_stream_empty(self):
249
"""Inserting an empty record stream should work."""
252
f.insert_record_stream([])
254
def assertIdenticalVersionedFile(self, left, right):
255
"""Assert that left and right have the same contents."""
256
self.assertEqual(set(left.versions()), set(right.versions()))
257
self.assertEqual(left.get_parent_map(left.versions()),
258
right.get_parent_map(right.versions()))
259
for v in left.versions():
260
self.assertEqual(left.get_text(v), right.get_text(v))
262
def test_insert_record_stream_fulltexts(self):
263
"""Any file should accept a stream of fulltexts."""
265
weave_vf = WeaveFile('source', get_transport(self.get_url('.')),
266
create=True, get_scope=self.get_transaction)
267
source, _ = get_diamond_vf(weave_vf)
268
stream = source.get_record_stream(source.versions(), 'topological',
270
f.insert_record_stream(stream)
271
self.assertIdenticalVersionedFile(f, source)
273
def test_insert_record_stream_fulltexts_noeol(self):
274
"""Any file should accept a stream of fulltexts."""
276
weave_vf = WeaveFile('source', get_transport(self.get_url('.')),
277
create=True, get_scope=self.get_transaction)
278
source, _ = get_diamond_vf(weave_vf, trailing_eol=False)
279
stream = source.get_record_stream(source.versions(), 'topological',
281
f.insert_record_stream(stream)
282
self.assertIdenticalVersionedFile(f, source)
284
def test_insert_record_stream_annotated_knits(self):
285
"""Any file should accept a stream from plain knits."""
287
source = make_file_knit('source', get_transport(self.get_url('.')),
289
get_diamond_vf(source)
290
stream = source.get_record_stream(source.versions(), 'topological',
292
f.insert_record_stream(stream)
293
self.assertIdenticalVersionedFile(f, source)
295
def test_insert_record_stream_annotated_knits_noeol(self):
296
"""Any file should accept a stream from plain knits."""
298
source = make_file_knit('source', get_transport(self.get_url('.')),
300
get_diamond_vf(source, trailing_eol=False)
301
stream = source.get_record_stream(source.versions(), 'topological',
303
f.insert_record_stream(stream)
304
self.assertIdenticalVersionedFile(f, source)
306
def test_insert_record_stream_plain_knits(self):
307
"""Any file should accept a stream from plain knits."""
309
source = make_file_knit('source', get_transport(self.get_url('.')),
310
create=True, factory=KnitPlainFactory())
311
get_diamond_vf(source)
312
stream = source.get_record_stream(source.versions(), 'topological',
314
f.insert_record_stream(stream)
315
self.assertIdenticalVersionedFile(f, source)
317
def test_insert_record_stream_plain_knits_noeol(self):
318
"""Any file should accept a stream from plain knits."""
320
source = make_file_knit('source', get_transport(self.get_url('.')),
321
create=True, factory=KnitPlainFactory())
322
get_diamond_vf(source, trailing_eol=False)
323
stream = source.get_record_stream(source.versions(), 'topological',
325
f.insert_record_stream(stream)
326
self.assertIdenticalVersionedFile(f, source)
328
def test_insert_record_stream_existing_keys(self):
329
"""Inserting keys already in a file should not error."""
331
source = make_file_knit('source', get_transport(self.get_url('.')),
332
create=True, factory=KnitPlainFactory())
333
get_diamond_vf(source)
334
# insert some keys into f.
335
get_diamond_vf(f, left_only=True)
336
stream = source.get_record_stream(source.versions(), 'topological',
338
f.insert_record_stream(stream)
339
self.assertIdenticalVersionedFile(f, source)
341
def test_insert_record_stream_missing_keys(self):
342
"""Inserting a stream with absent keys should raise an error."""
344
source = make_file_knit('source', get_transport(self.get_url('.')),
345
create=True, factory=KnitPlainFactory())
346
stream = source.get_record_stream(['missing'], 'topological',
348
self.assertRaises(errors.RevisionNotPresent, f.insert_record_stream,
351
def test_insert_record_stream_out_of_order(self):
352
"""An out of order stream can either error or work."""
353
f, parents = get_diamond_vf(self.get_file())
354
origin_entries = f.get_record_stream(['origin'], 'unordered', False)
355
end_entries = f.get_record_stream(['merged', 'left'],
356
'topological', False)
357
start_entries = f.get_record_stream(['right', 'base'],
358
'topological', False)
359
entries = chain(origin_entries, end_entries, start_entries)
360
target = self.get_file('target')
362
target.insert_record_stream(entries)
363
except RevisionNotPresent:
364
# Must not have corrupted the file.
367
self.assertIdenticalVersionedFile(f, target)
369
def test_insert_record_stream_delta_missing_basis_no_corruption(self):
370
"""Insertion where a needed basis is not included aborts safely."""
371
# Annotated source - deltas can be used in any knit.
372
source = make_file_knit('source', get_transport(self.get_url('.')),
374
get_diamond_vf(source)
375
entries = source.get_record_stream(['origin', 'merged'], 'unordered', False)
377
self.assertRaises(RevisionNotPresent, f.insert_record_stream, entries)
379
self.assertFalse(f.has_version('merged'))
381
def test_adds_with_parent_texts(self):
384
_, _, parent_texts['r0'] = f.add_lines('r0', [], ['a\n', 'b\n'])
386
_, _, parent_texts['r1'] = f.add_lines_with_ghosts('r1',
387
['r0', 'ghost'], ['b\n', 'c\n'], parent_texts=parent_texts)
388
except NotImplementedError:
389
# if the format doesn't support ghosts, just add normally.
390
_, _, parent_texts['r1'] = f.add_lines('r1',
391
['r0'], ['b\n', 'c\n'], parent_texts=parent_texts)
392
f.add_lines('r2', ['r1'], ['c\n', 'd\n'], parent_texts=parent_texts)
393
self.assertNotEqual(None, parent_texts['r0'])
394
self.assertNotEqual(None, parent_texts['r1'])
396
versions = f.versions()
397
self.assertTrue('r0' in versions)
398
self.assertTrue('r1' in versions)
399
self.assertTrue('r2' in versions)
400
self.assertEquals(f.get_lines('r0'), ['a\n', 'b\n'])
401
self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
402
self.assertEquals(f.get_lines('r2'), ['c\n', 'd\n'])
403
self.assertEqual(3, f.num_versions())
404
origins = f.annotate('r1')
405
self.assertEquals(origins[0][0], 'r0')
406
self.assertEquals(origins[1][0], 'r1')
407
origins = f.annotate('r2')
408
self.assertEquals(origins[0][0], 'r1')
409
self.assertEquals(origins[1][0], 'r2')
412
f = self.reopen_file()
415
def test_add_unicode_content(self):
416
# unicode content is not permitted in versioned files.
417
# versioned files version sequences of bytes only.
419
self.assertRaises(errors.BzrBadParameterUnicode,
420
vf.add_lines, 'a', [], ['a\n', u'b\n', 'c\n'])
422
(errors.BzrBadParameterUnicode, NotImplementedError),
423
vf.add_lines_with_ghosts, 'a', [], ['a\n', u'b\n', 'c\n'])
425
def test_add_follows_left_matching_blocks(self):
426
"""If we change left_matching_blocks, delta changes
428
Note: There are multiple correct deltas in this case, because
429
we start with 1 "a" and we get 3.
432
if isinstance(vf, WeaveFile):
433
raise TestSkipped("WeaveFile ignores left_matching_blocks")
434
vf.add_lines('1', [], ['a\n'])
435
vf.add_lines('2', ['1'], ['a\n', 'a\n', 'a\n'],
436
left_matching_blocks=[(0, 0, 1), (1, 3, 0)])
437
self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('2'))
438
vf.add_lines('3', ['1'], ['a\n', 'a\n', 'a\n'],
439
left_matching_blocks=[(0, 2, 1), (1, 3, 0)])
440
self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('3'))
442
def test_inline_newline_throws(self):
443
# \r characters are not permitted in lines being added
445
self.assertRaises(errors.BzrBadParameterContainsNewline,
446
vf.add_lines, 'a', [], ['a\n\n'])
448
(errors.BzrBadParameterContainsNewline, NotImplementedError),
449
vf.add_lines_with_ghosts, 'a', [], ['a\n\n'])
450
# but inline CR's are allowed
451
vf.add_lines('a', [], ['a\r\n'])
453
vf.add_lines_with_ghosts('b', [], ['a\r\n'])
454
except NotImplementedError:
457
def test_add_reserved(self):
459
self.assertRaises(errors.ReservedId,
460
vf.add_lines, 'a:', [], ['a\n', 'b\n', 'c\n'])
462
def test_add_lines_nostoresha(self):
463
"""When nostore_sha is supplied using old content raises."""
465
empty_text = ('a', [])
466
sample_text_nl = ('b', ["foo\n", "bar\n"])
467
sample_text_no_nl = ('c', ["foo\n", "bar"])
469
for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
470
sha, _, _ = vf.add_lines(version, [], lines)
472
# we now have a copy of all the lines in the vf.
473
for sha, (version, lines) in zip(
474
shas, (empty_text, sample_text_nl, sample_text_no_nl)):
475
self.assertRaises(errors.ExistingContent,
476
vf.add_lines, version + "2", [], lines,
478
# and no new version should have been added.
479
self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
482
def test_add_lines_with_ghosts_nostoresha(self):
483
"""When nostore_sha is supplied using old content raises."""
485
empty_text = ('a', [])
486
sample_text_nl = ('b', ["foo\n", "bar\n"])
487
sample_text_no_nl = ('c', ["foo\n", "bar"])
489
for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
490
sha, _, _ = vf.add_lines(version, [], lines)
492
# we now have a copy of all the lines in the vf.
493
# is the test applicable to this vf implementation?
495
vf.add_lines_with_ghosts('d', [], [])
496
except NotImplementedError:
497
raise TestSkipped("add_lines_with_ghosts is optional")
498
for sha, (version, lines) in zip(
499
shas, (empty_text, sample_text_nl, sample_text_no_nl)):
500
self.assertRaises(errors.ExistingContent,
501
vf.add_lines_with_ghosts, version + "2", [], lines,
503
# and no new version should have been added.
504
self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
507
def test_add_lines_return_value(self):
508
# add_lines should return the sha1 and the text size.
510
empty_text = ('a', [])
511
sample_text_nl = ('b', ["foo\n", "bar\n"])
512
sample_text_no_nl = ('c', ["foo\n", "bar"])
513
# check results for the three cases:
514
for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
515
# the first two elements are the same for all versioned files:
516
# - the digest and the size of the text. For some versioned files
517
# additional data is returned in additional tuple elements.
518
result = vf.add_lines(version, [], lines)
519
self.assertEqual(3, len(result))
520
self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
522
# parents should not affect the result:
523
lines = sample_text_nl[1]
524
self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
525
vf.add_lines('d', ['b', 'c'], lines)[0:2])
527
def test_get_reserved(self):
529
self.assertRaises(errors.ReservedId, vf.get_texts, ['b:'])
530
self.assertRaises(errors.ReservedId, vf.get_lines, 'b:')
531
self.assertRaises(errors.ReservedId, vf.get_text, 'b:')
533
def test_add_unchanged_last_line_noeol_snapshot(self):
534
"""Add a text with an unchanged last line with no eol should work."""
535
# Test adding this in a number of chain lengths; because the interface
536
# for VersionedFile does not allow forcing a specific chain length, we
537
# just use a small base to get the first snapshot, then a much longer
538
# first line for the next add (which will make the third add snapshot)
539
# and so on. 20 has been chosen as an aribtrary figure - knits use 200
540
# as a capped delta length, but ideally we would have some way of
541
# tuning the test to the store (e.g. keep going until a snapshot
543
for length in range(20):
545
vf = self.get_file('case-%d' % length)
548
for step in range(length):
549
version = prefix % step
550
lines = (['prelude \n'] * step) + ['line']
551
vf.add_lines(version, parents, lines)
552
version_lines[version] = lines
554
vf.add_lines('no-eol', parents, ['line'])
555
vf.get_texts(version_lines.keys())
556
self.assertEqualDiff('line', vf.get_text('no-eol'))
558
def test_get_texts_eol_variation(self):
559
# similar to the failure in <http://bugs.launchpad.net/234748>
561
sample_text_nl = ["line\n"]
562
sample_text_no_nl = ["line"]
569
lines = sample_text_nl
571
lines = sample_text_no_nl
572
# left_matching blocks is an internal api; it operates on the
573
# *internal* representation for a knit, which is with *all* lines
574
# being normalised to end with \n - even the final line in a no_nl
575
# file. Using it here ensures that a broken internal implementation
576
# (which is what this test tests) will generate a correct line
577
# delta (which is to say, an empty delta).
578
vf.add_lines(version, parents, lines,
579
left_matching_blocks=[(0, 0, 1)])
581
versions.append(version)
582
version_lines[version] = lines
584
vf.get_texts(versions)
585
vf.get_texts(reversed(versions))
587
def test_add_lines_with_matching_blocks_noeol_last_line(self):
588
"""Add a text with an unchanged last line with no eol should work."""
589
from bzrlib import multiparent
590
# Hand verified sha1 of the text we're adding.
591
sha1 = '6a1d115ec7b60afb664dc14890b5af5ce3c827a4'
592
# Create a mpdiff which adds a new line before the trailing line, and
593
# reuse the last line unaltered (which can cause annotation reuse).
594
# Test adding this in two situations:
595
# On top of a new insertion
596
vf = self.get_file('fulltext')
597
vf.add_lines('noeol', [], ['line'])
598
vf.add_lines('noeol2', ['noeol'], ['newline\n', 'line'],
599
left_matching_blocks=[(0, 1, 1)])
600
self.assertEqualDiff('newline\nline', vf.get_text('noeol2'))
602
vf = self.get_file('delta')
603
vf.add_lines('base', [], ['line'])
604
vf.add_lines('noeol', ['base'], ['prelude\n', 'line'])
605
vf.add_lines('noeol2', ['noeol'], ['newline\n', 'line'],
606
left_matching_blocks=[(1, 1, 1)])
607
self.assertEqualDiff('newline\nline', vf.get_text('noeol2'))
609
def test_make_mpdiffs(self):
610
from bzrlib import multiparent
611
vf = self.get_file('foo')
612
sha1s = self._setup_for_deltas(vf)
613
new_vf = self.get_file('bar')
614
for version in multiparent.topo_iter(vf):
615
mpdiff = vf.make_mpdiffs([version])[0]
616
new_vf.add_mpdiffs([(version, vf.get_parent_map([version])[version],
617
vf.get_sha1s([version])[0], mpdiff)])
618
self.assertEqualDiff(vf.get_text(version),
619
new_vf.get_text(version))
621
def test_make_mpdiffs_with_ghosts(self):
622
vf = self.get_file('foo')
624
vf.add_lines_with_ghosts('text', ['ghost'], ['line\n'])
625
except NotImplementedError:
626
# old Weave formats do not allow ghosts
628
self.assertRaises(errors.RevisionNotPresent, vf.make_mpdiffs, ['ghost'])
630
def _setup_for_deltas(self, f):
631
self.assertFalse(f.has_version('base'))
632
# add texts that should trip the knit maximum delta chain threshold
633
# as well as doing parallel chains of data in knits.
634
# this is done by two chains of 25 insertions
635
f.add_lines('base', [], ['line\n'])
636
f.add_lines('noeol', ['base'], ['line'])
637
# detailed eol tests:
638
# shared last line with parent no-eol
639
f.add_lines('noeolsecond', ['noeol'], ['line\n', 'line'])
640
# differing last line with parent, both no-eol
641
f.add_lines('noeolnotshared', ['noeolsecond'], ['line\n', 'phone'])
642
# add eol following a noneol parent, change content
643
f.add_lines('eol', ['noeol'], ['phone\n'])
644
# add eol following a noneol parent, no change content
645
f.add_lines('eolline', ['noeol'], ['line\n'])
646
# noeol with no parents:
647
f.add_lines('noeolbase', [], ['line'])
648
# noeol preceeding its leftmost parent in the output:
649
# this is done by making it a merge of two parents with no common
650
# anestry: noeolbase and noeol with the
651
# later-inserted parent the leftmost.
652
f.add_lines('eolbeforefirstparent', ['noeolbase', 'noeol'], ['line'])
653
# two identical eol texts
654
f.add_lines('noeoldup', ['noeol'], ['line'])
656
text_name = 'chain1-'
658
sha1s = {0 :'da6d3141cb4a5e6f464bf6e0518042ddc7bfd079',
659
1 :'45e21ea146a81ea44a821737acdb4f9791c8abe7',
660
2 :'e1f11570edf3e2a070052366c582837a4fe4e9fa',
661
3 :'26b4b8626da827088c514b8f9bbe4ebf181edda1',
662
4 :'e28a5510be25ba84d31121cff00956f9970ae6f6',
663
5 :'d63ec0ce22e11dcf65a931b69255d3ac747a318d',
664
6 :'2c2888d288cb5e1d98009d822fedfe6019c6a4ea',
665
7 :'95c14da9cafbf828e3e74a6f016d87926ba234ab',
666
8 :'779e9a0b28f9f832528d4b21e17e168c67697272',
667
9 :'1f8ff4e5c6ff78ac106fcfe6b1e8cb8740ff9a8f',
668
10:'131a2ae712cf51ed62f143e3fbac3d4206c25a05',
669
11:'c5a9d6f520d2515e1ec401a8f8a67e6c3c89f199',
670
12:'31a2286267f24d8bedaa43355f8ad7129509ea85',
671
13:'dc2a7fe80e8ec5cae920973973a8ee28b2da5e0a',
672
14:'2c4b1736566b8ca6051e668de68650686a3922f2',
673
15:'5912e4ecd9b0c07be4d013e7e2bdcf9323276cde',
674
16:'b0d2e18d3559a00580f6b49804c23fea500feab3',
675
17:'8e1d43ad72f7562d7cb8f57ee584e20eb1a69fc7',
676
18:'5cf64a3459ae28efa60239e44b20312d25b253f3',
677
19:'1ebed371807ba5935958ad0884595126e8c4e823',
678
20:'2aa62a8b06fb3b3b892a3292a068ade69d5ee0d3',
679
21:'01edc447978004f6e4e962b417a4ae1955b6fe5d',
680
22:'d8d8dc49c4bf0bab401e0298bb5ad827768618bb',
681
23:'c21f62b1c482862983a8ffb2b0c64b3451876e3f',
682
24:'c0593fe795e00dff6b3c0fe857a074364d5f04fc',
683
25:'dd1a1cf2ba9cc225c3aff729953e6364bf1d1855',
685
for depth in range(26):
686
new_version = text_name + '%s' % depth
687
text = text + ['line\n']
688
f.add_lines(new_version, [next_parent], text)
689
next_parent = new_version
691
text_name = 'chain2-'
693
for depth in range(26):
694
new_version = text_name + '%s' % depth
695
text = text + ['line\n']
696
f.add_lines(new_version, [next_parent], text)
697
next_parent = new_version
700
def test_ancestry(self):
702
self.assertEqual([], f.get_ancestry([]))
703
f.add_lines('r0', [], ['a\n', 'b\n'])
704
f.add_lines('r1', ['r0'], ['b\n', 'c\n'])
705
f.add_lines('r2', ['r0'], ['b\n', 'c\n'])
706
f.add_lines('r3', ['r2'], ['b\n', 'c\n'])
707
f.add_lines('rM', ['r1', 'r2'], ['b\n', 'c\n'])
708
self.assertEqual([], f.get_ancestry([]))
709
versions = f.get_ancestry(['rM'])
710
# there are some possibilities:
714
# so we check indexes
715
r0 = versions.index('r0')
716
r1 = versions.index('r1')
717
r2 = versions.index('r2')
718
self.assertFalse('r3' in versions)
719
rM = versions.index('rM')
720
self.assertTrue(r0 < r1)
721
self.assertTrue(r0 < r2)
722
self.assertTrue(r1 < rM)
723
self.assertTrue(r2 < rM)
725
self.assertRaises(RevisionNotPresent,
726
f.get_ancestry, ['rM', 'rX'])
728
self.assertEqual(set(f.get_ancestry('rM')),
729
set(f.get_ancestry('rM', topo_sorted=False)))
731
def test_mutate_after_finish(self):
732
self._transaction = 'before'
734
self._transaction = 'after'
735
self.assertRaises(errors.OutSideTransaction, f.add_lines, '', [], [])
736
self.assertRaises(errors.OutSideTransaction, f.add_lines_with_ghosts, '', [], [])
737
self.assertRaises(errors.OutSideTransaction, self.applyDeprecated,
738
one_five, f.join, '')
740
def test_copy_to(self):
742
f.add_lines('0', [], ['a\n'])
743
t = MemoryTransport()
745
for suffix in self.get_factory().get_suffixes():
746
self.assertTrue(t.has('foo' + suffix))
748
def test_get_suffixes(self):
750
# and should be a list
751
self.assertTrue(isinstance(self.get_factory().get_suffixes(), list))
753
def test_get_parent_map(self):
755
f.add_lines('r0', [], ['a\n', 'b\n'])
757
{'r0':()}, f.get_parent_map(['r0']))
758
f.add_lines('r1', ['r0'], ['a\n', 'b\n'])
760
{'r1':('r0',)}, f.get_parent_map(['r1']))
764
f.get_parent_map(['r0', 'r1']))
765
f.add_lines('r2', [], ['a\n', 'b\n'])
766
f.add_lines('r3', [], ['a\n', 'b\n'])
767
f.add_lines('m', ['r0', 'r1', 'r2', 'r3'], ['a\n', 'b\n'])
769
{'m':('r0', 'r1', 'r2', 'r3')}, f.get_parent_map(['m']))
770
self.assertEqual({}, f.get_parent_map('y'))
774
f.get_parent_map(['r0', 'y', 'r1']))
776
def test_annotate(self):
778
f.add_lines('r0', [], ['a\n', 'b\n'])
779
f.add_lines('r1', ['r0'], ['c\n', 'b\n'])
780
origins = f.annotate('r1')
781
self.assertEquals(origins[0][0], 'r1')
782
self.assertEquals(origins[1][0], 'r0')
784
self.assertRaises(RevisionNotPresent,
787
def test_detection(self):
788
# Test weaves detect corruption.
790
# Weaves contain a checksum of their texts.
791
# When a text is extracted, this checksum should be
794
w = self.get_file_corrupted_text()
796
self.assertEqual('hello\n', w.get_text('v1'))
797
self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')
798
self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')
799
self.assertRaises(errors.WeaveInvalidChecksum, w.check)
801
w = self.get_file_corrupted_checksum()
803
self.assertEqual('hello\n', w.get_text('v1'))
804
self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')
805
self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')
806
self.assertRaises(errors.WeaveInvalidChecksum, w.check)
808
def get_file_corrupted_text(self):
809
"""Return a versioned file with corrupt text but valid metadata."""
810
raise NotImplementedError(self.get_file_corrupted_text)
812
def reopen_file(self, name='foo'):
813
"""Open the versioned file from disk again."""
814
raise NotImplementedError(self.reopen_file)
816
def test_iter_lines_added_or_present_in_versions(self):
817
# test that we get at least an equalset of the lines added by
818
# versions in the weave
819
# the ordering here is to make a tree so that dumb searches have
820
# more changes to muck up.
822
class InstrumentedProgress(progress.DummyProgress):
826
progress.DummyProgress.__init__(self)
829
def update(self, msg=None, current=None, total=None):
830
self.updates.append((msg, current, total))
833
# add a base to get included
834
vf.add_lines('base', [], ['base\n'])
835
# add a ancestor to be included on one side
836
vf.add_lines('lancestor', [], ['lancestor\n'])
837
# add a ancestor to be included on the other side
838
vf.add_lines('rancestor', ['base'], ['rancestor\n'])
839
# add a child of rancestor with no eofile-nl
840
vf.add_lines('child', ['rancestor'], ['base\n', 'child\n'])
841
# add a child of lancestor and base to join the two roots
842
vf.add_lines('otherchild',
843
['lancestor', 'base'],
844
['base\n', 'lancestor\n', 'otherchild\n'])
845
def iter_with_versions(versions, expected):
846
# now we need to see what lines are returned, and how often.
848
progress = InstrumentedProgress()
849
# iterate over the lines
850
for line in vf.iter_lines_added_or_present_in_versions(versions,
852
lines.setdefault(line, 0)
854
if []!= progress.updates:
855
self.assertEqual(expected, progress.updates)
857
lines = iter_with_versions(['child', 'otherchild'],
858
[('Walking content.', 0, 2),
859
('Walking content.', 1, 2),
860
('Walking content.', 2, 2)])
861
# we must see child and otherchild
862
self.assertTrue(lines[('child\n', 'child')] > 0)
863
self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
864
# we dont care if we got more than that.
867
lines = iter_with_versions(None, [('Walking content.', 0, 5),
868
('Walking content.', 1, 5),
869
('Walking content.', 2, 5),
870
('Walking content.', 3, 5),
871
('Walking content.', 4, 5),
872
('Walking content.', 5, 5)])
873
# all lines must be seen at least once
874
self.assertTrue(lines[('base\n', 'base')] > 0)
875
self.assertTrue(lines[('lancestor\n', 'lancestor')] > 0)
876
self.assertTrue(lines[('rancestor\n', 'rancestor')] > 0)
877
self.assertTrue(lines[('child\n', 'child')] > 0)
878
self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
880
def test_add_lines_with_ghosts(self):
881
# some versioned file formats allow lines to be added with parent
882
# information that is > than that in the format. Formats that do
883
# not support this need to raise NotImplementedError on the
884
# add_lines_with_ghosts api.
886
# add a revision with ghost parents
887
# The preferred form is utf8, but we should translate when needed
888
parent_id_unicode = u'b\xbfse'
889
parent_id_utf8 = parent_id_unicode.encode('utf8')
891
vf.add_lines_with_ghosts('notbxbfse', [parent_id_utf8], [])
892
except NotImplementedError:
893
# check the other ghost apis are also not implemented
894
self.assertRaises(NotImplementedError, vf.get_ancestry_with_ghosts, ['foo'])
895
self.assertRaises(NotImplementedError, vf.get_parents_with_ghosts, 'foo')
897
vf = self.reopen_file()
898
# test key graph related apis: getncestry, _graph, get_parents
900
# - these are ghost unaware and must not be reflect ghosts
901
self.assertEqual(['notbxbfse'], vf.get_ancestry('notbxbfse'))
902
self.assertFalse(vf.has_version(parent_id_utf8))
903
# we have _with_ghost apis to give us ghost information.
904
self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry_with_ghosts(['notbxbfse']))
905
self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
906
# if we add something that is a ghost of another, it should correct the
907
# results of the prior apis
908
vf.add_lines(parent_id_utf8, [], [])
909
self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry(['notbxbfse']))
910
self.assertEqual({'notbxbfse':(parent_id_utf8,)},
911
vf.get_parent_map(['notbxbfse']))
912
self.assertTrue(vf.has_version(parent_id_utf8))
913
# we have _with_ghost apis to give us ghost information.
914
self.assertEqual([parent_id_utf8, 'notbxbfse'],
915
vf.get_ancestry_with_ghosts(['notbxbfse']))
916
self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
918
def test_add_lines_with_ghosts_after_normal_revs(self):
919
# some versioned file formats allow lines to be added with parent
920
# information that is > than that in the format. Formats that do
921
# not support this need to raise NotImplementedError on the
922
# add_lines_with_ghosts api.
924
# probe for ghost support
926
vf.add_lines_with_ghosts('base', [], ['line\n', 'line_b\n'])
927
except NotImplementedError:
929
vf.add_lines_with_ghosts('references_ghost',
931
['line\n', 'line_b\n', 'line_c\n'])
932
origins = vf.annotate('references_ghost')
933
self.assertEquals(('base', 'line\n'), origins[0])
934
self.assertEquals(('base', 'line_b\n'), origins[1])
935
self.assertEquals(('references_ghost', 'line_c\n'), origins[2])
937
def test_readonly_mode(self):
938
transport = get_transport(self.get_url('.'))
939
factory = self.get_factory()
940
vf = factory('id', transport, 0777, create=True, access_mode='w')
941
vf = factory('id', transport, access_mode='r')
942
self.assertRaises(errors.ReadOnlyError, vf.add_lines, 'base', [], [])
943
self.assertRaises(errors.ReadOnlyError,
944
vf.add_lines_with_ghosts,
948
self.assertRaises(errors.ReadOnlyError, self.applyDeprecated, one_five,
951
def test_get_sha1s(self):
952
# check the sha1 data is available
955
vf.add_lines('a', [], ['a\n'])
956
# the same file, different metadata
957
vf.add_lines('b', ['a'], ['a\n'])
958
# a file differing only in last newline.
959
vf.add_lines('c', [], ['a'])
960
self.assertEqual(['3f786850e387550fdab836ed7e6dc881de23001b',
961
'86f7e437faa5a7fce15d1ddcb9eaeaea377667b8',
962
'3f786850e387550fdab836ed7e6dc881de23001b'],
963
vf.get_sha1s(['a', 'c', 'b']))
966
class TestWeave(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
968
def get_file(self, name='foo'):
969
return WeaveFile(name, get_transport(self.get_url('.')), create=True,
970
get_scope=self.get_transaction)
972
def get_file_corrupted_text(self):
973
w = WeaveFile('foo', get_transport(self.get_url('.')), create=True,
974
get_scope=self.get_transaction)
975
w.add_lines('v1', [], ['hello\n'])
976
w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
978
# We are going to invasively corrupt the text
979
# Make sure the internals of weave are the same
980
self.assertEqual([('{', 0)
988
self.assertEqual(['f572d396fae9206628714fb2ce00f72e94f2258f'
989
, '90f265c6e75f1c8f9ab76dcf85528352c5f215ef'
994
w._weave[4] = 'There\n'
997
def get_file_corrupted_checksum(self):
998
w = self.get_file_corrupted_text()
1000
w._weave[4] = 'there\n'
1001
self.assertEqual('hello\nthere\n', w.get_text('v2'))
1003
#Invalid checksum, first digit changed
1004
w._sha1s[1] = 'f0f265c6e75f1c8f9ab76dcf85528352c5f215ef'
1007
def reopen_file(self, name='foo', create=False):
1008
return WeaveFile(name, get_transport(self.get_url('.')), create=create,
1009
get_scope=self.get_transaction)
1011
def test_no_implicit_create(self):
1012
self.assertRaises(errors.NoSuchFile,
1015
get_transport(self.get_url('.')),
1016
get_scope=self.get_transaction)
1018
def get_factory(self):
1022
class TestKnit(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
1024
def get_file(self, name='foo', create=True):
1025
return make_file_knit(name, get_transport(self.get_url('.')),
1026
delta=True, create=True, get_scope=self.get_transaction)
1028
def get_factory(self):
1029
return make_file_knit
1031
def get_file_corrupted_text(self):
1032
knit = self.get_file()
1033
knit.add_lines('v1', [], ['hello\n'])
1034
knit.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
1037
def reopen_file(self, name='foo', create=False):
1038
return self.get_file(name, create)
1040
def test_detection(self):
1041
knit = self.get_file()
1044
def test_no_implicit_create(self):
1045
self.assertRaises(errors.NoSuchFile, self.get_factory(), 'foo',
1046
get_transport(self.get_url('.')))
1049
class TestPlaintextKnit(TestKnit):
1050
"""Test a knit with no cached annotations"""
1052
def get_file(self, name='foo', create=True):
1053
return make_file_knit(name, get_transport(self.get_url('.')),
1054
delta=True, create=create, get_scope=self.get_transaction,
1055
factory=_mod_knit.KnitPlainFactory())
1058
class TestPlanMergeVersionedFile(TestCaseWithMemoryTransport):
1061
TestCaseWithMemoryTransport.setUp(self)
1062
self.vf1 = make_file_knit('root', self.get_transport(), create=True)
1063
self.vf2 = make_file_knit('root', self.get_transport(), create=True)
1064
self.plan_merge_vf = versionedfile._PlanMergeVersionedFile('root',
1065
[self.vf1, self.vf2])
1067
def test_add_lines(self):
1068
self.plan_merge_vf.add_lines('a:', [], [])
1069
self.assertRaises(ValueError, self.plan_merge_vf.add_lines, 'a', [],
1071
self.assertRaises(ValueError, self.plan_merge_vf.add_lines, 'a:', None,
1073
self.assertRaises(ValueError, self.plan_merge_vf.add_lines, 'a:', [],
1076
def test_ancestry(self):
1077
self.vf1.add_lines('A', [], [])
1078
self.vf1.add_lines('B', ['A'], [])
1079
self.plan_merge_vf.add_lines('C:', ['B'], [])
1080
self.plan_merge_vf.add_lines('D:', ['C:'], [])
1081
self.assertEqual(set(['A', 'B', 'C:', 'D:']),
1082
self.plan_merge_vf.get_ancestry('D:', topo_sorted=False))
1084
def setup_abcde(self):
1085
self.vf1.add_lines('A', [], ['a'])
1086
self.vf1.add_lines('B', ['A'], ['b'])
1087
self.vf2.add_lines('C', [], ['c'])
1088
self.vf2.add_lines('D', ['C'], ['d'])
1089
self.plan_merge_vf.add_lines('E:', ['B', 'D'], ['e'])
1091
def test_ancestry_uses_all_versionedfiles(self):
1093
self.assertEqual(set(['A', 'B', 'C', 'D', 'E:']),
1094
self.plan_merge_vf.get_ancestry('E:', topo_sorted=False))
1096
def test_ancestry_raises_revision_not_present(self):
1097
error = self.assertRaises(errors.RevisionNotPresent,
1098
self.plan_merge_vf.get_ancestry, 'E:', False)
1099
self.assertContainsRe(str(error), '{E:} not present in "root"')
1101
def test_get_parents(self):
1103
self.assertEqual({'B':('A',)}, self.plan_merge_vf.get_parent_map(['B']))
1104
self.assertEqual({'D':('C',)}, self.plan_merge_vf.get_parent_map(['D']))
1105
self.assertEqual({'E:':('B', 'D')},
1106
self.plan_merge_vf.get_parent_map(['E:']))
1107
self.assertEqual({}, self.plan_merge_vf.get_parent_map(['F']))
1112
}, self.plan_merge_vf.get_parent_map(['B', 'D', 'E:', 'F']))
1114
def test_get_lines(self):
1116
self.assertEqual(['a'], self.plan_merge_vf.get_lines('A'))
1117
self.assertEqual(['c'], self.plan_merge_vf.get_lines('C'))
1118
self.assertEqual(['e'], self.plan_merge_vf.get_lines('E:'))
1119
error = self.assertRaises(errors.RevisionNotPresent,
1120
self.plan_merge_vf.get_lines, 'F')
1121
self.assertContainsRe(str(error), '{F} not present in "root"')
1124
class InterString(versionedfile.InterVersionedFile):
1125
"""An inter-versionedfile optimised code path for strings.
1127
This is for use during testing where we use strings as versionedfiles
1128
so that none of the default regsitered interversionedfile classes will
1129
match - which lets us test the match logic.
1133
def is_compatible(source, target):
1134
"""InterString is compatible with strings-as-versionedfiles."""
1135
return isinstance(source, str) and isinstance(target, str)
1138
# TODO this and the InterRepository core logic should be consolidatable
1139
# if we make the registry a separate class though we still need to
1140
# test the behaviour in the active registry to catch failure-to-handle-
1142
class TestInterVersionedFile(TestCaseWithMemoryTransport):
1144
def test_get_default_inter_versionedfile(self):
1145
# test that the InterVersionedFile.get(a, b) probes
1146
# for a class where is_compatible(a, b) returns
1147
# true and returns a default interversionedfile otherwise.
1148
# This also tests that the default registered optimised interversionedfile
1149
# classes do not barf inappropriately when a surprising versionedfile type
1150
# is handed to them.
1151
dummy_a = "VersionedFile 1."
1152
dummy_b = "VersionedFile 2."
1153
self.assertGetsDefaultInterVersionedFile(dummy_a, dummy_b)
1155
def assertGetsDefaultInterVersionedFile(self, a, b):
1156
"""Asserts that InterVersionedFile.get(a, b) -> the default."""
1157
inter = versionedfile.InterVersionedFile.get(a, b)
1158
self.assertEqual(versionedfile.InterVersionedFile,
1160
self.assertEqual(a, inter.source)
1161
self.assertEqual(b, inter.target)
1163
def test_register_inter_versionedfile_class(self):
1164
# test that a optimised code path provider - a
1165
# InterVersionedFile subclass can be registered and unregistered
1166
# and that it is correctly selected when given a versionedfile
1167
# pair that it returns true on for the is_compatible static method
1169
dummy_a = "VersionedFile 1."
1170
dummy_b = "VersionedFile 2."
1171
versionedfile.InterVersionedFile.register_optimiser(InterString)
1173
# we should get the default for something InterString returns False
1175
self.assertFalse(InterString.is_compatible(dummy_a, None))
1176
self.assertGetsDefaultInterVersionedFile(dummy_a, None)
1177
# and we should get an InterString for a pair it 'likes'
1178
self.assertTrue(InterString.is_compatible(dummy_a, dummy_b))
1179
inter = versionedfile.InterVersionedFile.get(dummy_a, dummy_b)
1180
self.assertEqual(InterString, inter.__class__)
1181
self.assertEqual(dummy_a, inter.source)
1182
self.assertEqual(dummy_b, inter.target)
1184
versionedfile.InterVersionedFile.unregister_optimiser(InterString)
1185
# now we should get the default InterVersionedFile object again.
1186
self.assertGetsDefaultInterVersionedFile(dummy_a, dummy_b)
1189
class TestReadonlyHttpMixin(object):
1191
def get_transaction(self):
1194
def test_readonly_http_works(self):
1195
# we should be able to read from http with a versioned file.
1196
vf = self.get_file()
1197
# try an empty file access
1198
readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
1199
self.assertEqual([], readonly_vf.versions())
1201
vf.add_lines('1', [], ['a\n'])
1202
vf.add_lines('2', ['1'], ['b\n', 'a\n'])
1203
readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
1204
self.assertEqual(['1', '2'], vf.versions())
1205
for version in readonly_vf.versions():
1206
readonly_vf.get_lines(version)
1209
class TestWeaveHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
1212
return WeaveFile('foo', get_transport(self.get_url('.')), create=True,
1213
get_scope=self.get_transaction)
1215
def get_factory(self):
1219
class TestKnitHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
1222
return make_file_knit('foo', get_transport(self.get_url('.')),
1223
delta=True, create=True, get_scope=self.get_transaction)
1225
def get_factory(self):
1226
return make_file_knit
1229
class MergeCasesMixin(object):
1231
def doMerge(self, base, a, b, mp):
1232
from cStringIO import StringIO
1233
from textwrap import dedent
1239
w.add_lines('text0', [], map(addcrlf, base))
1240
w.add_lines('text1', ['text0'], map(addcrlf, a))
1241
w.add_lines('text2', ['text0'], map(addcrlf, b))
1243
self.log_contents(w)
1245
self.log('merge plan:')
1246
p = list(w.plan_merge('text1', 'text2'))
1247
for state, line in p:
1249
self.log('%12s | %s' % (state, line[:-1]))
1253
mt.writelines(w.weave_merge(p))
1255
self.log(mt.getvalue())
1257
mp = map(addcrlf, mp)
1258
self.assertEqual(mt.readlines(), mp)
1261
def testOneInsert(self):
1267
def testSeparateInserts(self):
1268
self.doMerge(['aaa', 'bbb', 'ccc'],
1269
['aaa', 'xxx', 'bbb', 'ccc'],
1270
['aaa', 'bbb', 'yyy', 'ccc'],
1271
['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
1273
def testSameInsert(self):
1274
self.doMerge(['aaa', 'bbb', 'ccc'],
1275
['aaa', 'xxx', 'bbb', 'ccc'],
1276
['aaa', 'xxx', 'bbb', 'yyy', 'ccc'],
1277
['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
1278
overlappedInsertExpected = ['aaa', 'xxx', 'yyy', 'bbb']
1279
def testOverlappedInsert(self):
1280
self.doMerge(['aaa', 'bbb'],
1281
['aaa', 'xxx', 'yyy', 'bbb'],
1282
['aaa', 'xxx', 'bbb'], self.overlappedInsertExpected)
1284
# really it ought to reduce this to
1285
# ['aaa', 'xxx', 'yyy', 'bbb']
1288
def testClashReplace(self):
1289
self.doMerge(['aaa'],
1292
['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz',
1295
def testNonClashInsert1(self):
1296
self.doMerge(['aaa'],
1299
['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz',
1302
def testNonClashInsert2(self):
1303
self.doMerge(['aaa'],
1309
def testDeleteAndModify(self):
1310
"""Clashing delete and modification.
1312
If one side modifies a region and the other deletes it then
1313
there should be a conflict with one side blank.
1316
#######################################
1317
# skippd, not working yet
1320
self.doMerge(['aaa', 'bbb', 'ccc'],
1321
['aaa', 'ddd', 'ccc'],
1323
['<<<<<<<< ', 'aaa', '=======', '>>>>>>> ', 'ccc'])
1325
def _test_merge_from_strings(self, base, a, b, expected):
1327
w.add_lines('text0', [], base.splitlines(True))
1328
w.add_lines('text1', ['text0'], a.splitlines(True))
1329
w.add_lines('text2', ['text0'], b.splitlines(True))
1330
self.log('merge plan:')
1331
p = list(w.plan_merge('text1', 'text2'))
1332
for state, line in p:
1334
self.log('%12s | %s' % (state, line[:-1]))
1335
self.log('merge result:')
1336
result_text = ''.join(w.weave_merge(p))
1337
self.log(result_text)
1338
self.assertEqualDiff(result_text, expected)
1340
def test_weave_merge_conflicts(self):
1341
# does weave merge properly handle plans that end with unchanged?
1342
result = ''.join(self.get_file().weave_merge([('new-a', 'hello\n')]))
1343
self.assertEqual(result, 'hello\n')
1345
def test_deletion_extended(self):
1346
"""One side deletes, the other deletes more.
1363
self._test_merge_from_strings(base, a, b, result)
1365
def test_deletion_overlap(self):
1366
"""Delete overlapping regions with no other conflict.
1368
Arguably it'd be better to treat these as agreement, rather than
1369
conflict, but for now conflict is safer.
1397
self._test_merge_from_strings(base, a, b, result)
1399
def test_agreement_deletion(self):
1400
"""Agree to delete some lines, without conflicts."""
1422
self._test_merge_from_strings(base, a, b, result)
1424
def test_sync_on_deletion(self):
1425
"""Specific case of merge where we can synchronize incorrectly.
1427
A previous version of the weave merge concluded that the two versions
1428
agreed on deleting line 2, and this could be a synchronization point.
1429
Line 1 was then considered in isolation, and thought to be deleted on
1432
It's better to consider the whole thing as a disagreement region.
1443
a's replacement line 2
1456
a's replacement line 2
1463
self._test_merge_from_strings(base, a, b, result)
1466
class TestKnitMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1468
def get_file(self, name='foo'):
1469
return make_file_knit(name, get_transport(self.get_url('.')),
1470
delta=True, create=True)
1472
def log_contents(self, w):
1476
class TestWeaveMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1478
def get_file(self, name='foo'):
1479
return WeaveFile(name, get_transport(self.get_url('.')), create=True)
1481
def log_contents(self, w):
1482
self.log('weave is:')
1484
write_weave(w, tmpf)
1485
self.log(tmpf.getvalue())
1487
overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======',
1488
'xxx', '>>>>>>> ', 'bbb']
1491
class TestContentFactoryAdaption(TestCaseWithMemoryTransport):
1493
def test_select_adaptor(self):
1494
"""Test expected adapters exist."""
1495
# One scenario for each lookup combination we expect to use.
1496
# Each is source_kind, requested_kind, adapter class
1498
('knit-delta-gz', 'fulltext', _mod_knit.DeltaPlainToFullText),
1499
('knit-ft-gz', 'fulltext', _mod_knit.FTPlainToFullText),
1500
('knit-annotated-delta-gz', 'knit-delta-gz',
1501
_mod_knit.DeltaAnnotatedToUnannotated),
1502
('knit-annotated-delta-gz', 'fulltext',
1503
_mod_knit.DeltaAnnotatedToFullText),
1504
('knit-annotated-ft-gz', 'knit-ft-gz',
1505
_mod_knit.FTAnnotatedToUnannotated),
1506
('knit-annotated-ft-gz', 'fulltext',
1507
_mod_knit.FTAnnotatedToFullText),
1509
for source, requested, klass in scenarios:
1510
adapter_factory = versionedfile.adapter_registry.get(
1511
(source, requested))
1512
adapter = adapter_factory(None)
1513
self.assertIsInstance(adapter, klass)
1515
def get_knit(self, annotated=True):
1517
factory = KnitAnnotateFactory()
1519
factory = KnitPlainFactory()
1520
return make_file_knit('knit', self.get_transport('.'), delta=True,
1521
create=True, factory=factory)
1523
def helpGetBytes(self, f, ft_adapter, delta_adapter):
1524
"""Grab the interested adapted texts for tests."""
1525
# origin is a fulltext
1526
entries = f.get_record_stream(['origin'], 'unordered', False)
1527
base = entries.next()
1528
ft_data = ft_adapter.get_bytes(base, base.get_bytes_as(base.storage_kind))
1529
# merged is both a delta and multiple parents.
1530
entries = f.get_record_stream(['merged'], 'unordered', False)
1531
merged = entries.next()
1532
delta_data = delta_adapter.get_bytes(merged,
1533
merged.get_bytes_as(merged.storage_kind))
1534
return ft_data, delta_data
1536
def test_deannotation_noeol(self):
1537
"""Test converting annotated knits to unannotated knits."""
1538
# we need a full text, and a delta
1539
f, parents = get_diamond_vf(self.get_knit(), trailing_eol=False)
1540
ft_data, delta_data = self.helpGetBytes(f,
1541
_mod_knit.FTAnnotatedToUnannotated(None),
1542
_mod_knit.DeltaAnnotatedToUnannotated(None))
1544
'version origin 1 b284f94827db1fa2970d9e2014f080413b547a7e\n'
1547
GzipFile(mode='rb', fileobj=StringIO(ft_data)).read())
1549
'version merged 4 32c2e79763b3f90e8ccde37f9710b6629c25a796\n'
1550
'1,2,3\nleft\nright\nmerged\nend merged\n',
1551
GzipFile(mode='rb', fileobj=StringIO(delta_data)).read())
1553
def test_deannotation(self):
1554
"""Test converting annotated knits to unannotated knits."""
1555
# we need a full text, and a delta
1556
f, parents = get_diamond_vf(self.get_knit())
1557
ft_data, delta_data = self.helpGetBytes(f,
1558
_mod_knit.FTAnnotatedToUnannotated(None),
1559
_mod_knit.DeltaAnnotatedToUnannotated(None))
1561
'version origin 1 00e364d235126be43292ab09cb4686cf703ddc17\n'
1564
GzipFile(mode='rb', fileobj=StringIO(ft_data)).read())
1566
'version merged 3 ed8bce375198ea62444dc71952b22cfc2b09226d\n'
1567
'2,2,2\nright\nmerged\nend merged\n',
1568
GzipFile(mode='rb', fileobj=StringIO(delta_data)).read())
1570
def test_annotated_to_fulltext_no_eol(self):
1571
"""Test adapting annotated knits to full texts (for -> weaves)."""
1572
# we need a full text, and a delta
1573
f, parents = get_diamond_vf(self.get_knit(), trailing_eol=False)
1574
# Reconstructing a full text requires a backing versioned file, and it
1575
# must have the base lines requested from it.
1576
logged_vf = versionedfile.RecordingVersionedFileDecorator(f)
1577
ft_data, delta_data = self.helpGetBytes(f,
1578
_mod_knit.FTAnnotatedToFullText(None),
1579
_mod_knit.DeltaAnnotatedToFullText(logged_vf))
1580
self.assertEqual('origin', ft_data)
1581
self.assertEqual('base\nleft\nright\nmerged', delta_data)
1582
self.assertEqual([('get_lines', 'left')], logged_vf.calls)
1584
def test_annotated_to_fulltext(self):
1585
"""Test adapting annotated knits to full texts (for -> weaves)."""
1586
# we need a full text, and a delta
1587
f, parents = get_diamond_vf(self.get_knit())
1588
# Reconstructing a full text requires a backing versioned file, and it
1589
# must have the base lines requested from it.
1590
logged_vf = versionedfile.RecordingVersionedFileDecorator(f)
1591
ft_data, delta_data = self.helpGetBytes(f,
1592
_mod_knit.FTAnnotatedToFullText(None),
1593
_mod_knit.DeltaAnnotatedToFullText(logged_vf))
1594
self.assertEqual('origin\n', ft_data)
1595
self.assertEqual('base\nleft\nright\nmerged\n', delta_data)
1596
self.assertEqual([('get_lines', 'left')], logged_vf.calls)
1598
def test_unannotated_to_fulltext(self):
1599
"""Test adapting unannotated knits to full texts.
1601
This is used for -> weaves, and for -> annotated knits.
1603
# we need a full text, and a delta
1604
f, parents = get_diamond_vf(self.get_knit(annotated=False))
1605
# Reconstructing a full text requires a backing versioned file, and it
1606
# must have the base lines requested from it.
1607
logged_vf = versionedfile.RecordingVersionedFileDecorator(f)
1608
ft_data, delta_data = self.helpGetBytes(f,
1609
_mod_knit.FTPlainToFullText(None),
1610
_mod_knit.DeltaPlainToFullText(logged_vf))
1611
self.assertEqual('origin\n', ft_data)
1612
self.assertEqual('base\nleft\nright\nmerged\n', delta_data)
1613
self.assertEqual([('get_lines', 'left')], logged_vf.calls)
1615
def test_unannotated_to_fulltext_no_eol(self):
1616
"""Test adapting unannotated knits to full texts.
1618
This is used for -> weaves, and for -> annotated knits.
1620
# we need a full text, and a delta
1621
f, parents = get_diamond_vf(self.get_knit(annotated=False),
1623
# Reconstructing a full text requires a backing versioned file, and it
1624
# must have the base lines requested from it.
1625
logged_vf = versionedfile.RecordingVersionedFileDecorator(f)
1626
ft_data, delta_data = self.helpGetBytes(f,
1627
_mod_knit.FTPlainToFullText(None),
1628
_mod_knit.DeltaPlainToFullText(logged_vf))
1629
self.assertEqual('origin', ft_data)
1630
self.assertEqual('base\nleft\nright\nmerged', delta_data)
1631
self.assertEqual([('get_lines', 'left')], logged_vf.calls)
added
removed
bzrlib/tests/test_versionedfile.py
