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 StringIO import StringIO
32
from bzrlib.errors import (
34
RevisionAlreadyPresent,
37
from bzrlib.knit import (
42
from bzrlib.tests import TestCaseWithMemoryTransport, TestSkipped
43
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
44
from bzrlib.trace import mutter
45
from bzrlib.transport import get_transport
46
from bzrlib.transport.memory import MemoryTransport
47
from bzrlib.tsort import topo_sort
48
import bzrlib.versionedfile as versionedfile
49
from bzrlib.weave import WeaveFile
50
from bzrlib.weavefile import read_weave, write_weave
53
class VersionedFileTestMixIn(object):
54
"""A mixin test class for testing VersionedFiles.
56
This is not an adaptor-style test at this point because
57
theres no dynamic substitution of versioned file implementations,
58
they are strictly controlled by their owning repositories.
63
f.add_lines('r0', [], ['a\n', 'b\n'])
64
f.add_lines('r1', ['r0'], ['b\n', 'c\n'])
66
versions = f.versions()
67
self.assertTrue('r0' in versions)
68
self.assertTrue('r1' in versions)
69
self.assertEquals(f.get_lines('r0'), ['a\n', 'b\n'])
70
self.assertEquals(f.get_text('r0'), 'a\nb\n')
71
self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
72
self.assertEqual(2, len(f))
73
self.assertEqual(2, f.num_versions())
75
self.assertRaises(RevisionNotPresent,
76
f.add_lines, 'r2', ['foo'], [])
77
self.assertRaises(RevisionAlreadyPresent,
78
f.add_lines, 'r1', [], [])
80
# this checks that reopen with create=True does not break anything.
81
f = self.reopen_file(create=True)
84
def test_adds_with_parent_texts(self):
87
_, _, parent_texts['r0'] = f.add_lines('r0', [], ['a\n', 'b\n'])
89
_, _, parent_texts['r1'] = f.add_lines_with_ghosts('r1',
90
['r0', 'ghost'], ['b\n', 'c\n'], parent_texts=parent_texts)
91
except NotImplementedError:
92
# if the format doesn't support ghosts, just add normally.
93
_, _, parent_texts['r1'] = f.add_lines('r1',
94
['r0'], ['b\n', 'c\n'], parent_texts=parent_texts)
95
f.add_lines('r2', ['r1'], ['c\n', 'd\n'], parent_texts=parent_texts)
96
self.assertNotEqual(None, parent_texts['r0'])
97
self.assertNotEqual(None, parent_texts['r1'])
99
versions = f.versions()
100
self.assertTrue('r0' in versions)
101
self.assertTrue('r1' in versions)
102
self.assertTrue('r2' in versions)
103
self.assertEquals(f.get_lines('r0'), ['a\n', 'b\n'])
104
self.assertEquals(f.get_lines('r1'), ['b\n', 'c\n'])
105
self.assertEquals(f.get_lines('r2'), ['c\n', 'd\n'])
106
self.assertEqual(3, f.num_versions())
107
origins = f.annotate('r1')
108
self.assertEquals(origins[0][0], 'r0')
109
self.assertEquals(origins[1][0], 'r1')
110
origins = f.annotate('r2')
111
self.assertEquals(origins[0][0], 'r1')
112
self.assertEquals(origins[1][0], 'r2')
115
f = self.reopen_file()
118
def test_add_unicode_content(self):
119
# unicode content is not permitted in versioned files.
120
# versioned files version sequences of bytes only.
122
self.assertRaises(errors.BzrBadParameterUnicode,
123
vf.add_lines, 'a', [], ['a\n', u'b\n', 'c\n'])
125
(errors.BzrBadParameterUnicode, NotImplementedError),
126
vf.add_lines_with_ghosts, 'a', [], ['a\n', u'b\n', 'c\n'])
128
def test_add_follows_left_matching_blocks(self):
129
"""If we change left_matching_blocks, delta changes
131
Note: There are multiple correct deltas in this case, because
132
we start with 1 "a" and we get 3.
135
if isinstance(vf, WeaveFile):
136
raise TestSkipped("WeaveFile ignores left_matching_blocks")
137
vf.add_lines('1', [], ['a\n'])
138
vf.add_lines('2', ['1'], ['a\n', 'a\n', 'a\n'],
139
left_matching_blocks=[(0, 0, 1), (1, 3, 0)])
140
self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('2'))
141
vf.add_lines('3', ['1'], ['a\n', 'a\n', 'a\n'],
142
left_matching_blocks=[(0, 2, 1), (1, 3, 0)])
143
self.assertEqual(['a\n', 'a\n', 'a\n'], vf.get_lines('3'))
145
def test_inline_newline_throws(self):
146
# \r characters are not permitted in lines being added
148
self.assertRaises(errors.BzrBadParameterContainsNewline,
149
vf.add_lines, 'a', [], ['a\n\n'])
151
(errors.BzrBadParameterContainsNewline, NotImplementedError),
152
vf.add_lines_with_ghosts, 'a', [], ['a\n\n'])
153
# but inline CR's are allowed
154
vf.add_lines('a', [], ['a\r\n'])
156
vf.add_lines_with_ghosts('b', [], ['a\r\n'])
157
except NotImplementedError:
160
def test_add_reserved(self):
162
self.assertRaises(errors.ReservedId,
163
vf.add_lines, 'a:', [], ['a\n', 'b\n', 'c\n'])
165
def test_add_lines_nostoresha(self):
166
"""When nostore_sha is supplied using old content raises."""
168
empty_text = ('a', [])
169
sample_text_nl = ('b', ["foo\n", "bar\n"])
170
sample_text_no_nl = ('c', ["foo\n", "bar"])
172
for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
173
sha, _, _ = vf.add_lines(version, [], lines)
175
# we now have a copy of all the lines in the vf.
176
for sha, (version, lines) in zip(
177
shas, (empty_text, sample_text_nl, sample_text_no_nl)):
178
self.assertRaises(errors.ExistingContent,
179
vf.add_lines, version + "2", [], lines,
181
# and no new version should have been added.
182
self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
185
def test_add_lines_with_ghosts_nostoresha(self):
186
"""When nostore_sha is supplied using old content raises."""
188
empty_text = ('a', [])
189
sample_text_nl = ('b', ["foo\n", "bar\n"])
190
sample_text_no_nl = ('c', ["foo\n", "bar"])
192
for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
193
sha, _, _ = vf.add_lines(version, [], lines)
195
# we now have a copy of all the lines in the vf.
196
# is the test applicable to this vf implementation?
198
vf.add_lines_with_ghosts('d', [], [])
199
except NotImplementedError:
200
raise TestSkipped("add_lines_with_ghosts is optional")
201
for sha, (version, lines) in zip(
202
shas, (empty_text, sample_text_nl, sample_text_no_nl)):
203
self.assertRaises(errors.ExistingContent,
204
vf.add_lines_with_ghosts, version + "2", [], lines,
206
# and no new version should have been added.
207
self.assertRaises(errors.RevisionNotPresent, vf.get_lines,
210
def test_add_lines_return_value(self):
211
# add_lines should return the sha1 and the text size.
213
empty_text = ('a', [])
214
sample_text_nl = ('b', ["foo\n", "bar\n"])
215
sample_text_no_nl = ('c', ["foo\n", "bar"])
216
# check results for the three cases:
217
for version, lines in (empty_text, sample_text_nl, sample_text_no_nl):
218
# the first two elements are the same for all versioned files:
219
# - the digest and the size of the text. For some versioned files
220
# additional data is returned in additional tuple elements.
221
result = vf.add_lines(version, [], lines)
222
self.assertEqual(3, len(result))
223
self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
225
# parents should not affect the result:
226
lines = sample_text_nl[1]
227
self.assertEqual((osutils.sha_strings(lines), sum(map(len, lines))),
228
vf.add_lines('d', ['b', 'c'], lines)[0:2])
230
def test_get_reserved(self):
232
self.assertRaises(errors.ReservedId, vf.get_texts, ['b:'])
233
self.assertRaises(errors.ReservedId, vf.get_lines, 'b:')
234
self.assertRaises(errors.ReservedId, vf.get_text, 'b:')
236
def test_make_mpdiffs(self):
237
from bzrlib import multiparent
238
vf = self.get_file('foo')
239
sha1s = self._setup_for_deltas(vf)
240
new_vf = self.get_file('bar')
241
for version in multiparent.topo_iter(vf):
242
mpdiff = vf.make_mpdiffs([version])[0]
243
new_vf.add_mpdiffs([(version, vf.get_parents(version),
244
vf.get_sha1(version), mpdiff)])
245
self.assertEqualDiff(vf.get_text(version),
246
new_vf.get_text(version))
248
def _setup_for_deltas(self, f):
249
self.assertFalse(f.has_version('base'))
250
# add texts that should trip the knit maximum delta chain threshold
251
# as well as doing parallel chains of data in knits.
252
# this is done by two chains of 25 insertions
253
f.add_lines('base', [], ['line\n'])
254
f.add_lines('noeol', ['base'], ['line'])
255
# detailed eol tests:
256
# shared last line with parent no-eol
257
f.add_lines('noeolsecond', ['noeol'], ['line\n', 'line'])
258
# differing last line with parent, both no-eol
259
f.add_lines('noeolnotshared', ['noeolsecond'], ['line\n', 'phone'])
260
# add eol following a noneol parent, change content
261
f.add_lines('eol', ['noeol'], ['phone\n'])
262
# add eol following a noneol parent, no change content
263
f.add_lines('eolline', ['noeol'], ['line\n'])
264
# noeol with no parents:
265
f.add_lines('noeolbase', [], ['line'])
266
# noeol preceeding its leftmost parent in the output:
267
# this is done by making it a merge of two parents with no common
268
# anestry: noeolbase and noeol with the
269
# later-inserted parent the leftmost.
270
f.add_lines('eolbeforefirstparent', ['noeolbase', 'noeol'], ['line'])
271
# two identical eol texts
272
f.add_lines('noeoldup', ['noeol'], ['line'])
274
text_name = 'chain1-'
276
sha1s = {0 :'da6d3141cb4a5e6f464bf6e0518042ddc7bfd079',
277
1 :'45e21ea146a81ea44a821737acdb4f9791c8abe7',
278
2 :'e1f11570edf3e2a070052366c582837a4fe4e9fa',
279
3 :'26b4b8626da827088c514b8f9bbe4ebf181edda1',
280
4 :'e28a5510be25ba84d31121cff00956f9970ae6f6',
281
5 :'d63ec0ce22e11dcf65a931b69255d3ac747a318d',
282
6 :'2c2888d288cb5e1d98009d822fedfe6019c6a4ea',
283
7 :'95c14da9cafbf828e3e74a6f016d87926ba234ab',
284
8 :'779e9a0b28f9f832528d4b21e17e168c67697272',
285
9 :'1f8ff4e5c6ff78ac106fcfe6b1e8cb8740ff9a8f',
286
10:'131a2ae712cf51ed62f143e3fbac3d4206c25a05',
287
11:'c5a9d6f520d2515e1ec401a8f8a67e6c3c89f199',
288
12:'31a2286267f24d8bedaa43355f8ad7129509ea85',
289
13:'dc2a7fe80e8ec5cae920973973a8ee28b2da5e0a',
290
14:'2c4b1736566b8ca6051e668de68650686a3922f2',
291
15:'5912e4ecd9b0c07be4d013e7e2bdcf9323276cde',
292
16:'b0d2e18d3559a00580f6b49804c23fea500feab3',
293
17:'8e1d43ad72f7562d7cb8f57ee584e20eb1a69fc7',
294
18:'5cf64a3459ae28efa60239e44b20312d25b253f3',
295
19:'1ebed371807ba5935958ad0884595126e8c4e823',
296
20:'2aa62a8b06fb3b3b892a3292a068ade69d5ee0d3',
297
21:'01edc447978004f6e4e962b417a4ae1955b6fe5d',
298
22:'d8d8dc49c4bf0bab401e0298bb5ad827768618bb',
299
23:'c21f62b1c482862983a8ffb2b0c64b3451876e3f',
300
24:'c0593fe795e00dff6b3c0fe857a074364d5f04fc',
301
25:'dd1a1cf2ba9cc225c3aff729953e6364bf1d1855',
303
for depth in range(26):
304
new_version = text_name + '%s' % depth
305
text = text + ['line\n']
306
f.add_lines(new_version, [next_parent], text)
307
next_parent = new_version
309
text_name = 'chain2-'
311
for depth in range(26):
312
new_version = text_name + '%s' % depth
313
text = text + ['line\n']
314
f.add_lines(new_version, [next_parent], text)
315
next_parent = new_version
318
def test_ancestry(self):
320
self.assertEqual([], f.get_ancestry([]))
321
f.add_lines('r0', [], ['a\n', 'b\n'])
322
f.add_lines('r1', ['r0'], ['b\n', 'c\n'])
323
f.add_lines('r2', ['r0'], ['b\n', 'c\n'])
324
f.add_lines('r3', ['r2'], ['b\n', 'c\n'])
325
f.add_lines('rM', ['r1', 'r2'], ['b\n', 'c\n'])
326
self.assertEqual([], f.get_ancestry([]))
327
versions = f.get_ancestry(['rM'])
328
# there are some possibilities:
332
# so we check indexes
333
r0 = versions.index('r0')
334
r1 = versions.index('r1')
335
r2 = versions.index('r2')
336
self.assertFalse('r3' in versions)
337
rM = versions.index('rM')
338
self.assertTrue(r0 < r1)
339
self.assertTrue(r0 < r2)
340
self.assertTrue(r1 < rM)
341
self.assertTrue(r2 < rM)
343
self.assertRaises(RevisionNotPresent,
344
f.get_ancestry, ['rM', 'rX'])
346
self.assertEqual(set(f.get_ancestry('rM')),
347
set(f.get_ancestry('rM', topo_sorted=False)))
349
def test_mutate_after_finish(self):
351
f.transaction_finished()
352
self.assertRaises(errors.OutSideTransaction, f.add_lines, '', [], [])
353
self.assertRaises(errors.OutSideTransaction, f.add_lines_with_ghosts, '', [], [])
354
self.assertRaises(errors.OutSideTransaction, f.join, '')
355
self.assertRaises(errors.OutSideTransaction, f.clone_text, 'base', 'bar', ['foo'])
357
def test_clear_cache(self):
359
# on a new file it should not error
361
# and after adding content, doing a clear_cache and a get should work.
362
f.add_lines('0', [], ['a'])
364
self.assertEqual(['a'], f.get_lines('0'))
366
def test_clone_text(self):
368
f.add_lines('r0', [], ['a\n', 'b\n'])
369
f.clone_text('r1', 'r0', ['r0'])
371
self.assertEquals(f.get_lines('r1'), f.get_lines('r0'))
372
self.assertEquals(f.get_lines('r1'), ['a\n', 'b\n'])
373
self.assertEquals(f.get_parents('r1'), ['r0'])
375
self.assertRaises(RevisionNotPresent,
376
f.clone_text, 'r2', 'rX', [])
377
self.assertRaises(RevisionAlreadyPresent,
378
f.clone_text, 'r1', 'r0', [])
380
verify_file(self.reopen_file())
382
def test_create_empty(self):
384
f.add_lines('0', [], ['a\n'])
385
new_f = f.create_empty('t', MemoryTransport())
386
# smoke test, specific types should check it is honoured correctly for
387
# non type attributes
388
self.assertEqual([], new_f.versions())
389
self.assertTrue(isinstance(new_f, f.__class__))
391
def test_copy_to(self):
393
f.add_lines('0', [], ['a\n'])
394
t = MemoryTransport()
396
for suffix in f.__class__.get_suffixes():
397
self.assertTrue(t.has('foo' + suffix))
399
def test_get_suffixes(self):
402
self.assertEqual(f.__class__.get_suffixes(), f.__class__.get_suffixes())
403
# and should be a list
404
self.assertTrue(isinstance(f.__class__.get_suffixes(), list))
406
def build_graph(self, file, graph):
407
for node in topo_sort(graph.items()):
408
file.add_lines(node, graph[node], [])
410
def test_get_graph(self):
416
self.build_graph(f, graph)
417
self.assertEqual(graph, f.get_graph())
419
def test_get_graph_partial(self):
427
complex_graph.update(simple_a)
432
complex_graph.update(simple_b)
439
complex_graph.update(simple_gam)
441
simple_b_gam.update(simple_gam)
442
simple_b_gam.update(simple_b)
443
self.build_graph(f, complex_graph)
444
self.assertEqual(simple_a, f.get_graph(['a']))
445
self.assertEqual(simple_b, f.get_graph(['b']))
446
self.assertEqual(simple_gam, f.get_graph(['gam']))
447
self.assertEqual(simple_b_gam, f.get_graph(['b', 'gam']))
449
def test_get_parents(self):
451
f.add_lines('r0', [], ['a\n', 'b\n'])
452
f.add_lines('r1', [], ['a\n', 'b\n'])
453
f.add_lines('r2', [], ['a\n', 'b\n'])
454
f.add_lines('r3', [], ['a\n', 'b\n'])
455
f.add_lines('m', ['r0', 'r1', 'r2', 'r3'], ['a\n', 'b\n'])
456
self.assertEquals(f.get_parents('m'), ['r0', 'r1', 'r2', 'r3'])
458
self.assertRaises(RevisionNotPresent,
461
def test_annotate(self):
463
f.add_lines('r0', [], ['a\n', 'b\n'])
464
f.add_lines('r1', ['r0'], ['c\n', 'b\n'])
465
origins = f.annotate('r1')
466
self.assertEquals(origins[0][0], 'r1')
467
self.assertEquals(origins[1][0], 'r0')
469
self.assertRaises(RevisionNotPresent,
472
def test_detection(self):
473
# Test weaves detect corruption.
475
# Weaves contain a checksum of their texts.
476
# When a text is extracted, this checksum should be
479
w = self.get_file_corrupted_text()
481
self.assertEqual('hello\n', w.get_text('v1'))
482
self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')
483
self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')
484
self.assertRaises(errors.WeaveInvalidChecksum, w.check)
486
w = self.get_file_corrupted_checksum()
488
self.assertEqual('hello\n', w.get_text('v1'))
489
self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')
490
self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')
491
self.assertRaises(errors.WeaveInvalidChecksum, w.check)
493
def get_file_corrupted_text(self):
494
"""Return a versioned file with corrupt text but valid metadata."""
495
raise NotImplementedError(self.get_file_corrupted_text)
497
def reopen_file(self, name='foo'):
498
"""Open the versioned file from disk again."""
499
raise NotImplementedError(self.reopen_file)
501
def test_iter_parents(self):
502
"""iter_parents returns the parents for many nodes."""
506
f.add_lines('r0', [], ['a\n', 'b\n'])
508
f.add_lines('r1', ['r0'], ['a\n', 'b\n'])
510
f.add_lines('r2', ['r1', 'r0'], ['a\n', 'b\n'])
512
# cases: each sample data individually:
513
self.assertEqual(set([('r0', ())]),
514
set(f.iter_parents(['r0'])))
515
self.assertEqual(set([('r1', ('r0', ))]),
516
set(f.iter_parents(['r1'])))
517
self.assertEqual(set([('r2', ('r1', 'r0'))]),
518
set(f.iter_parents(['r2'])))
519
# no nodes returned for a missing node
520
self.assertEqual(set(),
521
set(f.iter_parents(['missing'])))
522
# 1 node returned with missing nodes skipped
523
self.assertEqual(set([('r1', ('r0', ))]),
524
set(f.iter_parents(['ghost1', 'r1', 'ghost'])))
526
self.assertEqual(set([('r0', ()), ('r1', ('r0', ))]),
527
set(f.iter_parents(['r0', 'r1'])))
528
# 2 nodes returned, missing skipped
529
self.assertEqual(set([('r0', ()), ('r1', ('r0', ))]),
530
set(f.iter_parents(['a', 'r0', 'b', 'r1', 'c'])))
532
def test_iter_lines_added_or_present_in_versions(self):
533
# test that we get at least an equalset of the lines added by
534
# versions in the weave
535
# the ordering here is to make a tree so that dumb searches have
536
# more changes to muck up.
538
class InstrumentedProgress(progress.DummyProgress):
542
progress.DummyProgress.__init__(self)
545
def update(self, msg=None, current=None, total=None):
546
self.updates.append((msg, current, total))
549
# add a base to get included
550
vf.add_lines('base', [], ['base\n'])
551
# add a ancestor to be included on one side
552
vf.add_lines('lancestor', [], ['lancestor\n'])
553
# add a ancestor to be included on the other side
554
vf.add_lines('rancestor', ['base'], ['rancestor\n'])
555
# add a child of rancestor with no eofile-nl
556
vf.add_lines('child', ['rancestor'], ['base\n', 'child\n'])
557
# add a child of lancestor and base to join the two roots
558
vf.add_lines('otherchild',
559
['lancestor', 'base'],
560
['base\n', 'lancestor\n', 'otherchild\n'])
561
def iter_with_versions(versions, expected):
562
# now we need to see what lines are returned, and how often.
564
progress = InstrumentedProgress()
565
# iterate over the lines
566
for line in vf.iter_lines_added_or_present_in_versions(versions,
568
lines.setdefault(line, 0)
570
if []!= progress.updates:
571
self.assertEqual(expected, progress.updates)
573
lines = iter_with_versions(['child', 'otherchild'],
574
[('Walking content.', 0, 2),
575
('Walking content.', 1, 2),
576
('Walking content.', 2, 2)])
577
# we must see child and otherchild
578
self.assertTrue(lines[('child\n', 'child')] > 0)
579
self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
580
# we dont care if we got more than that.
583
lines = iter_with_versions(None, [('Walking content.', 0, 5),
584
('Walking content.', 1, 5),
585
('Walking content.', 2, 5),
586
('Walking content.', 3, 5),
587
('Walking content.', 4, 5),
588
('Walking content.', 5, 5)])
589
# all lines must be seen at least once
590
self.assertTrue(lines[('base\n', 'base')] > 0)
591
self.assertTrue(lines[('lancestor\n', 'lancestor')] > 0)
592
self.assertTrue(lines[('rancestor\n', 'rancestor')] > 0)
593
self.assertTrue(lines[('child\n', 'child')] > 0)
594
self.assertTrue(lines[('otherchild\n', 'otherchild')] > 0)
596
def test_add_lines_with_ghosts(self):
597
# some versioned file formats allow lines to be added with parent
598
# information that is > than that in the format. Formats that do
599
# not support this need to raise NotImplementedError on the
600
# add_lines_with_ghosts api.
602
# add a revision with ghost parents
603
# The preferred form is utf8, but we should translate when needed
604
parent_id_unicode = u'b\xbfse'
605
parent_id_utf8 = parent_id_unicode.encode('utf8')
607
vf.add_lines_with_ghosts('notbxbfse', [parent_id_utf8], [])
608
except NotImplementedError:
609
# check the other ghost apis are also not implemented
610
self.assertRaises(NotImplementedError, vf.has_ghost, 'foo')
611
self.assertRaises(NotImplementedError, vf.get_ancestry_with_ghosts, ['foo'])
612
self.assertRaises(NotImplementedError, vf.get_parents_with_ghosts, 'foo')
613
self.assertRaises(NotImplementedError, vf.get_graph_with_ghosts)
615
vf = self.reopen_file()
616
# test key graph related apis: getncestry, _graph, get_parents
618
# - these are ghost unaware and must not be reflect ghosts
619
self.assertEqual(['notbxbfse'], vf.get_ancestry('notbxbfse'))
620
self.assertEqual([], vf.get_parents('notbxbfse'))
621
self.assertEqual({'notbxbfse':()}, vf.get_graph())
622
self.assertFalse(vf.has_version(parent_id_utf8))
623
# we have _with_ghost apis to give us ghost information.
624
self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry_with_ghosts(['notbxbfse']))
625
self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
626
self.assertEqual({'notbxbfse':[parent_id_utf8]}, vf.get_graph_with_ghosts())
627
self.assertTrue(vf.has_ghost(parent_id_utf8))
628
# if we add something that is a ghost of another, it should correct the
629
# results of the prior apis
630
vf.add_lines(parent_id_utf8, [], [])
631
self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry(['notbxbfse']))
632
self.assertEqual([parent_id_utf8], vf.get_parents('notbxbfse'))
633
self.assertEqual({parent_id_utf8:(),
634
'notbxbfse':(parent_id_utf8, ),
637
self.assertTrue(vf.has_version(parent_id_utf8))
638
# we have _with_ghost apis to give us ghost information.
639
self.assertEqual([parent_id_utf8, 'notbxbfse'],
640
vf.get_ancestry_with_ghosts(['notbxbfse']))
641
self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
642
self.assertEqual({parent_id_utf8:[],
643
'notbxbfse':[parent_id_utf8],
645
vf.get_graph_with_ghosts())
646
self.assertFalse(vf.has_ghost(parent_id_utf8))
648
def test_add_lines_with_ghosts_after_normal_revs(self):
649
# some versioned file formats allow lines to be added with parent
650
# information that is > than that in the format. Formats that do
651
# not support this need to raise NotImplementedError on the
652
# add_lines_with_ghosts api.
654
# probe for ghost support
657
except NotImplementedError:
659
vf.add_lines_with_ghosts('base', [], ['line\n', 'line_b\n'])
660
vf.add_lines_with_ghosts('references_ghost',
662
['line\n', 'line_b\n', 'line_c\n'])
663
origins = vf.annotate('references_ghost')
664
self.assertEquals(('base', 'line\n'), origins[0])
665
self.assertEquals(('base', 'line_b\n'), origins[1])
666
self.assertEquals(('references_ghost', 'line_c\n'), origins[2])
668
def test_readonly_mode(self):
669
transport = get_transport(self.get_url('.'))
670
factory = self.get_factory()
671
vf = factory('id', transport, 0777, create=True, access_mode='w')
672
vf = factory('id', transport, access_mode='r')
673
self.assertRaises(errors.ReadOnlyError, vf.add_lines, 'base', [], [])
674
self.assertRaises(errors.ReadOnlyError,
675
vf.add_lines_with_ghosts,
679
self.assertRaises(errors.ReadOnlyError, vf.join, 'base')
680
self.assertRaises(errors.ReadOnlyError, vf.clone_text, 'base', 'bar', ['foo'])
682
def test_get_sha1(self):
683
# check the sha1 data is available
686
vf.add_lines('a', [], ['a\n'])
687
# the same file, different metadata
688
vf.add_lines('b', ['a'], ['a\n'])
689
# a file differing only in last newline.
690
vf.add_lines('c', [], ['a'])
692
'3f786850e387550fdab836ed7e6dc881de23001b', vf.get_sha1('a'))
694
'3f786850e387550fdab836ed7e6dc881de23001b', vf.get_sha1('b'))
696
'86f7e437faa5a7fce15d1ddcb9eaeaea377667b8', vf.get_sha1('c'))
698
self.assertEqual(['3f786850e387550fdab836ed7e6dc881de23001b',
699
'86f7e437faa5a7fce15d1ddcb9eaeaea377667b8',
700
'3f786850e387550fdab836ed7e6dc881de23001b'],
701
vf.get_sha1s(['a', 'c', 'b']))
704
class TestWeave(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
706
def get_file(self, name='foo'):
707
return WeaveFile(name, get_transport(self.get_url('.')), create=True)
709
def get_file_corrupted_text(self):
710
w = WeaveFile('foo', get_transport(self.get_url('.')), create=True)
711
w.add_lines('v1', [], ['hello\n'])
712
w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
714
# We are going to invasively corrupt the text
715
# Make sure the internals of weave are the same
716
self.assertEqual([('{', 0)
724
self.assertEqual(['f572d396fae9206628714fb2ce00f72e94f2258f'
725
, '90f265c6e75f1c8f9ab76dcf85528352c5f215ef'
730
w._weave[4] = 'There\n'
733
def get_file_corrupted_checksum(self):
734
w = self.get_file_corrupted_text()
736
w._weave[4] = 'there\n'
737
self.assertEqual('hello\nthere\n', w.get_text('v2'))
739
#Invalid checksum, first digit changed
740
w._sha1s[1] = 'f0f265c6e75f1c8f9ab76dcf85528352c5f215ef'
743
def reopen_file(self, name='foo', create=False):
744
return WeaveFile(name, get_transport(self.get_url('.')), create=create)
746
def test_no_implicit_create(self):
747
self.assertRaises(errors.NoSuchFile,
750
get_transport(self.get_url('.')))
752
def get_factory(self):
756
class TestKnit(TestCaseWithMemoryTransport, VersionedFileTestMixIn):
758
def get_file(self, name='foo'):
759
return self.get_factory()(name, get_transport(self.get_url('.')),
760
delta=True, create=True)
762
def get_factory(self):
763
return KnitVersionedFile
765
def get_file_corrupted_text(self):
766
knit = self.get_file()
767
knit.add_lines('v1', [], ['hello\n'])
768
knit.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
771
def reopen_file(self, name='foo', create=False):
772
return self.get_factory()(name, get_transport(self.get_url('.')),
776
def test_detection(self):
777
knit = self.get_file()
780
def test_no_implicit_create(self):
781
self.assertRaises(errors.NoSuchFile,
784
get_transport(self.get_url('.')))
787
class TestPlaintextKnit(TestKnit):
788
"""Test a knit with no cached annotations"""
790
def _factory(self, name, transport, file_mode=None, access_mode=None,
791
delta=True, create=False):
792
return KnitVersionedFile(name, transport, file_mode, access_mode,
793
KnitPlainFactory(), delta=delta,
796
def get_factory(self):
800
class TestPlanMergeVersionedFile(TestCaseWithMemoryTransport):
803
TestCaseWithMemoryTransport.setUp(self)
804
self.vf1 = KnitVersionedFile('root', self.get_transport(), create=True)
805
self.vf2 = KnitVersionedFile('root', self.get_transport(), create=True)
806
self.plan_merge_vf = versionedfile._PlanMergeVersionedFile('root',
807
[self.vf1, self.vf2])
809
def test_add_lines(self):
810
self.plan_merge_vf.add_lines('a:', [], [])
811
self.assertRaises(ValueError, self.plan_merge_vf.add_lines, 'a', [],
813
self.assertRaises(ValueError, self.plan_merge_vf.add_lines, 'a:', None,
815
self.assertRaises(ValueError, self.plan_merge_vf.add_lines, 'a:', [],
818
def test_ancestry(self):
819
self.vf1.add_lines('A', [], [])
820
self.vf1.add_lines('B', ['A'], [])
821
self.plan_merge_vf.add_lines('C:', ['B'], [])
822
self.plan_merge_vf.add_lines('D:', ['C:'], [])
823
self.assertEqual(set(['A', 'B', 'C:', 'D:']),
824
self.plan_merge_vf.get_ancestry('D:', topo_sorted=False))
826
def setup_abcde(self):
827
self.vf1.add_lines('A', [], ['a'])
828
self.vf1.add_lines('B', ['A'], ['b'])
829
self.vf2.add_lines('C', [], ['c'])
830
self.vf2.add_lines('D', ['C'], ['d'])
831
self.plan_merge_vf.add_lines('E:', ['B', 'D'], ['e'])
833
def test_ancestry_uses_all_versionedfiles(self):
835
self.assertEqual(set(['A', 'B', 'C', 'D', 'E:']),
836
self.plan_merge_vf.get_ancestry('E:', topo_sorted=False))
838
def test_ancestry_raises_revision_not_present(self):
839
error = self.assertRaises(errors.RevisionNotPresent,
840
self.plan_merge_vf.get_ancestry, 'E:', False)
841
self.assertContainsRe(str(error), '{E:} not present in "root"')
843
def test_get_parents(self):
845
self.assertEqual(['A'], self.plan_merge_vf.get_parents('B'))
846
self.assertEqual(['C'], self.plan_merge_vf.get_parents('D'))
847
self.assertEqual(['B', 'D'], self.plan_merge_vf.get_parents('E:'))
848
error = self.assertRaises(errors.RevisionNotPresent,
849
self.plan_merge_vf.get_parents, 'F')
850
self.assertContainsRe(str(error), '{F} not present in "root"')
852
def test_get_lines(self):
854
self.assertEqual(['a'], self.plan_merge_vf.get_lines('A'))
855
self.assertEqual(['c'], self.plan_merge_vf.get_lines('C'))
856
self.assertEqual(['e'], self.plan_merge_vf.get_lines('E:'))
857
error = self.assertRaises(errors.RevisionNotPresent,
858
self.plan_merge_vf.get_lines, 'F')
859
self.assertContainsRe(str(error), '{F} not present in "root"')
862
class InterString(versionedfile.InterVersionedFile):
863
"""An inter-versionedfile optimised code path for strings.
865
This is for use during testing where we use strings as versionedfiles
866
so that none of the default regsitered interversionedfile classes will
867
match - which lets us test the match logic.
871
def is_compatible(source, target):
872
"""InterString is compatible with strings-as-versionedfiles."""
873
return isinstance(source, str) and isinstance(target, str)
876
# TODO this and the InterRepository core logic should be consolidatable
877
# if we make the registry a separate class though we still need to
878
# test the behaviour in the active registry to catch failure-to-handle-
880
class TestInterVersionedFile(TestCaseWithMemoryTransport):
882
def test_get_default_inter_versionedfile(self):
883
# test that the InterVersionedFile.get(a, b) probes
884
# for a class where is_compatible(a, b) returns
885
# true and returns a default interversionedfile otherwise.
886
# This also tests that the default registered optimised interversionedfile
887
# classes do not barf inappropriately when a surprising versionedfile type
889
dummy_a = "VersionedFile 1."
890
dummy_b = "VersionedFile 2."
891
self.assertGetsDefaultInterVersionedFile(dummy_a, dummy_b)
893
def assertGetsDefaultInterVersionedFile(self, a, b):
894
"""Asserts that InterVersionedFile.get(a, b) -> the default."""
895
inter = versionedfile.InterVersionedFile.get(a, b)
896
self.assertEqual(versionedfile.InterVersionedFile,
898
self.assertEqual(a, inter.source)
899
self.assertEqual(b, inter.target)
901
def test_register_inter_versionedfile_class(self):
902
# test that a optimised code path provider - a
903
# InterVersionedFile subclass can be registered and unregistered
904
# and that it is correctly selected when given a versionedfile
905
# pair that it returns true on for the is_compatible static method
907
dummy_a = "VersionedFile 1."
908
dummy_b = "VersionedFile 2."
909
versionedfile.InterVersionedFile.register_optimiser(InterString)
911
# we should get the default for something InterString returns False
913
self.assertFalse(InterString.is_compatible(dummy_a, None))
914
self.assertGetsDefaultInterVersionedFile(dummy_a, None)
915
# and we should get an InterString for a pair it 'likes'
916
self.assertTrue(InterString.is_compatible(dummy_a, dummy_b))
917
inter = versionedfile.InterVersionedFile.get(dummy_a, dummy_b)
918
self.assertEqual(InterString, inter.__class__)
919
self.assertEqual(dummy_a, inter.source)
920
self.assertEqual(dummy_b, inter.target)
922
versionedfile.InterVersionedFile.unregister_optimiser(InterString)
923
# now we should get the default InterVersionedFile object again.
924
self.assertGetsDefaultInterVersionedFile(dummy_a, dummy_b)
927
class TestReadonlyHttpMixin(object):
929
def test_readonly_http_works(self):
930
# we should be able to read from http with a versioned file.
932
# try an empty file access
933
readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
934
self.assertEqual([], readonly_vf.versions())
936
vf.add_lines('1', [], ['a\n'])
937
vf.add_lines('2', ['1'], ['b\n', 'a\n'])
938
readonly_vf = self.get_factory()('foo', get_transport(self.get_readonly_url('.')))
939
self.assertEqual(['1', '2'], vf.versions())
940
for version in readonly_vf.versions():
941
readonly_vf.get_lines(version)
944
class TestWeaveHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
947
return WeaveFile('foo', get_transport(self.get_url('.')), create=True)
949
def get_factory(self):
953
class TestKnitHTTP(TestCaseWithWebserver, TestReadonlyHttpMixin):
956
return KnitVersionedFile('foo', get_transport(self.get_url('.')),
957
delta=True, create=True)
959
def get_factory(self):
960
return KnitVersionedFile
963
class MergeCasesMixin(object):
965
def doMerge(self, base, a, b, mp):
966
from cStringIO import StringIO
967
from textwrap import dedent
973
w.add_lines('text0', [], map(addcrlf, base))
974
w.add_lines('text1', ['text0'], map(addcrlf, a))
975
w.add_lines('text2', ['text0'], map(addcrlf, b))
979
self.log('merge plan:')
980
p = list(w.plan_merge('text1', 'text2'))
981
for state, line in p:
983
self.log('%12s | %s' % (state, line[:-1]))
987
mt.writelines(w.weave_merge(p))
989
self.log(mt.getvalue())
991
mp = map(addcrlf, mp)
992
self.assertEqual(mt.readlines(), mp)
995
def testOneInsert(self):
1001
def testSeparateInserts(self):
1002
self.doMerge(['aaa', 'bbb', 'ccc'],
1003
['aaa', 'xxx', 'bbb', 'ccc'],
1004
['aaa', 'bbb', 'yyy', 'ccc'],
1005
['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
1007
def testSameInsert(self):
1008
self.doMerge(['aaa', 'bbb', 'ccc'],
1009
['aaa', 'xxx', 'bbb', 'ccc'],
1010
['aaa', 'xxx', 'bbb', 'yyy', 'ccc'],
1011
['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
1012
overlappedInsertExpected = ['aaa', 'xxx', 'yyy', 'bbb']
1013
def testOverlappedInsert(self):
1014
self.doMerge(['aaa', 'bbb'],
1015
['aaa', 'xxx', 'yyy', 'bbb'],
1016
['aaa', 'xxx', 'bbb'], self.overlappedInsertExpected)
1018
# really it ought to reduce this to
1019
# ['aaa', 'xxx', 'yyy', 'bbb']
1022
def testClashReplace(self):
1023
self.doMerge(['aaa'],
1026
['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz',
1029
def testNonClashInsert1(self):
1030
self.doMerge(['aaa'],
1033
['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz',
1036
def testNonClashInsert2(self):
1037
self.doMerge(['aaa'],
1043
def testDeleteAndModify(self):
1044
"""Clashing delete and modification.
1046
If one side modifies a region and the other deletes it then
1047
there should be a conflict with one side blank.
1050
#######################################
1051
# skippd, not working yet
1054
self.doMerge(['aaa', 'bbb', 'ccc'],
1055
['aaa', 'ddd', 'ccc'],
1057
['<<<<<<<< ', 'aaa', '=======', '>>>>>>> ', 'ccc'])
1059
def _test_merge_from_strings(self, base, a, b, expected):
1061
w.add_lines('text0', [], base.splitlines(True))
1062
w.add_lines('text1', ['text0'], a.splitlines(True))
1063
w.add_lines('text2', ['text0'], b.splitlines(True))
1064
self.log('merge plan:')
1065
p = list(w.plan_merge('text1', 'text2'))
1066
for state, line in p:
1068
self.log('%12s | %s' % (state, line[:-1]))
1069
self.log('merge result:')
1070
result_text = ''.join(w.weave_merge(p))
1071
self.log(result_text)
1072
self.assertEqualDiff(result_text, expected)
1074
def test_weave_merge_conflicts(self):
1075
# does weave merge properly handle plans that end with unchanged?
1076
result = ''.join(self.get_file().weave_merge([('new-a', 'hello\n')]))
1077
self.assertEqual(result, 'hello\n')
1079
def test_deletion_extended(self):
1080
"""One side deletes, the other deletes more.
1097
self._test_merge_from_strings(base, a, b, result)
1099
def test_deletion_overlap(self):
1100
"""Delete overlapping regions with no other conflict.
1102
Arguably it'd be better to treat these as agreement, rather than
1103
conflict, but for now conflict is safer.
1131
self._test_merge_from_strings(base, a, b, result)
1133
def test_agreement_deletion(self):
1134
"""Agree to delete some lines, without conflicts."""
1156
self._test_merge_from_strings(base, a, b, result)
1158
def test_sync_on_deletion(self):
1159
"""Specific case of merge where we can synchronize incorrectly.
1161
A previous version of the weave merge concluded that the two versions
1162
agreed on deleting line 2, and this could be a synchronization point.
1163
Line 1 was then considered in isolation, and thought to be deleted on
1166
It's better to consider the whole thing as a disagreement region.
1177
a's replacement line 2
1190
a's replacement line 2
1197
self._test_merge_from_strings(base, a, b, result)
1200
class TestKnitMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1202
def get_file(self, name='foo'):
1203
return KnitVersionedFile(name, get_transport(self.get_url('.')),
1204
delta=True, create=True)
1206
def log_contents(self, w):
1210
class TestWeaveMerge(TestCaseWithMemoryTransport, MergeCasesMixin):
1212
def get_file(self, name='foo'):
1213
return WeaveFile(name, get_transport(self.get_url('.')), create=True)
1215
def log_contents(self, w):
1216
self.log('weave is:')
1218
write_weave(w, tmpf)
1219
self.log(tmpf.getvalue())
1221
overlappedInsertExpected = ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======',
1222
'xxx', '>>>>>>> ', 'bbb']
1225
class TestFormatSignatures(TestCaseWithMemoryTransport):
1227
def get_knit_file(self, name, annotated):
1229
factory = KnitAnnotateFactory()
1231
factory = KnitPlainFactory()
1232
return KnitVersionedFile(
1233
name, get_transport(self.get_url('.')), create=True,
1236
def test_knit_format_signatures(self):
1237
"""Different formats of knit have different signature strings."""
1238
knit = self.get_knit_file('a', True)
1239
self.assertEqual('knit-annotated', knit.get_format_signature())
1240
knit = self.get_knit_file('p', False)
1241
self.assertEqual('knit-plain', knit.get_format_signature())
added
removed
bzrlib/tests/test_versionedfile.py
