1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Tests for Knit data structure"""
19
from cStringIO import StringIO
31
from bzrlib.errors import (
32
RevisionAlreadyPresent,
37
from bzrlib.index import *
38
from bzrlib.knit import (
55
from bzrlib.osutils import split_lines
56
from bzrlib.tests import (
59
TestCaseWithMemoryTransport,
60
TestCaseWithTransport,
62
from bzrlib.transport import get_transport
63
from bzrlib.transport.memory import MemoryTransport
64
from bzrlib.tuned_gzip import GzipFile
65
from bzrlib.util import bencode
66
from bzrlib.weave import Weave
69
class _CompiledKnitFeature(Feature):
73
import bzrlib._knit_load_data_c
78
def feature_name(self):
79
return 'bzrlib._knit_load_data_c'
81
CompiledKnitFeature = _CompiledKnitFeature()
84
class KnitContentTestsMixin(object):
86
def test_constructor(self):
87
content = self._make_content([])
90
content = self._make_content([])
91
self.assertEqual(content.text(), [])
93
content = self._make_content([("origin1", "text1"), ("origin2", "text2")])
94
self.assertEqual(content.text(), ["text1", "text2"])
97
content = self._make_content([("origin1", "text1"), ("origin2", "text2")])
99
self.assertIsInstance(copy, content.__class__)
100
self.assertEqual(copy.annotate(), content.annotate())
102
def assertDerivedBlocksEqual(self, source, target, noeol=False):
103
"""Assert that the derived matching blocks match real output"""
104
source_lines = source.splitlines(True)
105
target_lines = target.splitlines(True)
107
if noeol and not line.endswith('\n'):
111
source_content = self._make_content([(None, nl(l)) for l in source_lines])
112
target_content = self._make_content([(None, nl(l)) for l in target_lines])
113
line_delta = source_content.line_delta(target_content)
114
delta_blocks = list(KnitContent.get_line_delta_blocks(line_delta,
115
source_lines, target_lines))
116
matcher = KnitSequenceMatcher(None, source_lines, target_lines)
117
matcher_blocks = list(list(matcher.get_matching_blocks()))
118
self.assertEqual(matcher_blocks, delta_blocks)
120
def test_get_line_delta_blocks(self):
121
self.assertDerivedBlocksEqual('a\nb\nc\n', 'q\nc\n')
122
self.assertDerivedBlocksEqual(TEXT_1, TEXT_1)
123
self.assertDerivedBlocksEqual(TEXT_1, TEXT_1A)
124
self.assertDerivedBlocksEqual(TEXT_1, TEXT_1B)
125
self.assertDerivedBlocksEqual(TEXT_1B, TEXT_1A)
126
self.assertDerivedBlocksEqual(TEXT_1A, TEXT_1B)
127
self.assertDerivedBlocksEqual(TEXT_1A, '')
128
self.assertDerivedBlocksEqual('', TEXT_1A)
129
self.assertDerivedBlocksEqual('', '')
130
self.assertDerivedBlocksEqual('a\nb\nc', 'a\nb\nc\nd')
132
def test_get_line_delta_blocks_noeol(self):
133
"""Handle historical knit deltas safely
135
Some existing knit deltas don't consider the last line to differ
136
when the only difference whether it has a final newline.
138
New knit deltas appear to always consider the last line to differ
141
self.assertDerivedBlocksEqual('a\nb\nc', 'a\nb\nc\nd\n', noeol=True)
142
self.assertDerivedBlocksEqual('a\nb\nc\nd\n', 'a\nb\nc', noeol=True)
143
self.assertDerivedBlocksEqual('a\nb\nc\n', 'a\nb\nc', noeol=True)
144
self.assertDerivedBlocksEqual('a\nb\nc', 'a\nb\nc\n', noeol=True)
147
class TestPlainKnitContent(TestCase, KnitContentTestsMixin):
149
def _make_content(self, lines):
150
annotated_content = AnnotatedKnitContent(lines)
151
return PlainKnitContent(annotated_content.text(), 'bogus')
153
def test_annotate(self):
154
content = self._make_content([])
155
self.assertEqual(content.annotate(), [])
157
content = self._make_content([("origin1", "text1"), ("origin2", "text2")])
158
self.assertEqual(content.annotate(),
159
[("bogus", "text1"), ("bogus", "text2")])
161
def test_annotate_iter(self):
162
content = self._make_content([])
163
it = content.annotate_iter()
164
self.assertRaises(StopIteration, it.next)
166
content = self._make_content([("bogus", "text1"), ("bogus", "text2")])
167
it = content.annotate_iter()
168
self.assertEqual(it.next(), ("bogus", "text1"))
169
self.assertEqual(it.next(), ("bogus", "text2"))
170
self.assertRaises(StopIteration, it.next)
172
def test_line_delta(self):
173
content1 = self._make_content([("", "a"), ("", "b")])
174
content2 = self._make_content([("", "a"), ("", "a"), ("", "c")])
175
self.assertEqual(content1.line_delta(content2),
176
[(1, 2, 2, ["a", "c"])])
178
def test_line_delta_iter(self):
179
content1 = self._make_content([("", "a"), ("", "b")])
180
content2 = self._make_content([("", "a"), ("", "a"), ("", "c")])
181
it = content1.line_delta_iter(content2)
182
self.assertEqual(it.next(), (1, 2, 2, ["a", "c"]))
183
self.assertRaises(StopIteration, it.next)
186
class TestAnnotatedKnitContent(TestCase, KnitContentTestsMixin):
188
def _make_content(self, lines):
189
return AnnotatedKnitContent(lines)
191
def test_annotate(self):
192
content = self._make_content([])
193
self.assertEqual(content.annotate(), [])
195
content = self._make_content([("origin1", "text1"), ("origin2", "text2")])
196
self.assertEqual(content.annotate(),
197
[("origin1", "text1"), ("origin2", "text2")])
199
def test_annotate_iter(self):
200
content = self._make_content([])
201
it = content.annotate_iter()
202
self.assertRaises(StopIteration, it.next)
204
content = self._make_content([("origin1", "text1"), ("origin2", "text2")])
205
it = content.annotate_iter()
206
self.assertEqual(it.next(), ("origin1", "text1"))
207
self.assertEqual(it.next(), ("origin2", "text2"))
208
self.assertRaises(StopIteration, it.next)
210
def test_line_delta(self):
211
content1 = self._make_content([("", "a"), ("", "b")])
212
content2 = self._make_content([("", "a"), ("", "a"), ("", "c")])
213
self.assertEqual(content1.line_delta(content2),
214
[(1, 2, 2, [("", "a"), ("", "c")])])
216
def test_line_delta_iter(self):
217
content1 = self._make_content([("", "a"), ("", "b")])
218
content2 = self._make_content([("", "a"), ("", "a"), ("", "c")])
219
it = content1.line_delta_iter(content2)
220
self.assertEqual(it.next(), (1, 2, 2, [("", "a"), ("", "c")]))
221
self.assertRaises(StopIteration, it.next)
224
class MockTransport(object):
226
def __init__(self, file_lines=None):
227
self.file_lines = file_lines
229
# We have no base directory for the MockTransport
232
def get(self, filename):
233
if self.file_lines is None:
234
raise NoSuchFile(filename)
236
return StringIO("\n".join(self.file_lines))
238
def readv(self, relpath, offsets):
239
fp = self.get(relpath)
240
for offset, size in offsets:
242
yield offset, fp.read(size)
244
def __getattr__(self, name):
245
def queue_call(*args, **kwargs):
246
self.calls.append((name, args, kwargs))
250
class KnitRecordAccessTestsMixin(object):
251
"""Tests for getting and putting knit records."""
253
def assertAccessExists(self, access):
254
"""Ensure the data area for access has been initialised/exists."""
255
raise NotImplementedError(self.assertAccessExists)
257
def test_add_raw_records(self):
258
"""Add_raw_records adds records retrievable later."""
259
access = self.get_access()
260
memos = access.add_raw_records([10], '1234567890')
261
self.assertEqual(['1234567890'], list(access.get_raw_records(memos)))
263
def test_add_several_raw_records(self):
264
"""add_raw_records with many records and read some back."""
265
access = self.get_access()
266
memos = access.add_raw_records([10, 2, 5], '12345678901234567')
267
self.assertEqual(['1234567890', '12', '34567'],
268
list(access.get_raw_records(memos)))
269
self.assertEqual(['1234567890'],
270
list(access.get_raw_records(memos[0:1])))
271
self.assertEqual(['12'],
272
list(access.get_raw_records(memos[1:2])))
273
self.assertEqual(['34567'],
274
list(access.get_raw_records(memos[2:3])))
275
self.assertEqual(['1234567890', '34567'],
276
list(access.get_raw_records(memos[0:1] + memos[2:3])))
278
def test_create(self):
279
"""create() should make a file on disk."""
280
access = self.get_access()
282
self.assertAccessExists(access)
284
def test_open_file(self):
285
"""open_file never errors."""
286
access = self.get_access()
290
class TestKnitKnitAccess(TestCaseWithMemoryTransport, KnitRecordAccessTestsMixin):
291
"""Tests for the .kndx implementation."""
293
def assertAccessExists(self, access):
294
self.assertNotEqual(None, access.open_file())
296
def get_access(self):
297
"""Get a .knit style access instance."""
298
access = _KnitAccess(self.get_transport(), "foo.knit", None, None,
303
class TestPackKnitAccess(TestCaseWithMemoryTransport, KnitRecordAccessTestsMixin):
304
"""Tests for the pack based access."""
306
def assertAccessExists(self, access):
307
# as pack based access has no backing unless an index maps data, this
311
def get_access(self):
312
return self._get_access()[0]
314
def _get_access(self, packname='packfile', index='FOO'):
315
transport = self.get_transport()
316
def write_data(bytes):
317
transport.append_bytes(packname, bytes)
318
writer = pack.ContainerWriter(write_data)
320
indices = {index:(transport, packname)}
321
access = _PackAccess(indices, writer=(writer, index))
322
return access, writer
324
def test_read_from_several_packs(self):
325
access, writer = self._get_access()
327
memos.extend(access.add_raw_records([10], '1234567890'))
329
access, writer = self._get_access('pack2', 'FOOBAR')
330
memos.extend(access.add_raw_records([5], '12345'))
332
access, writer = self._get_access('pack3', 'BAZ')
333
memos.extend(access.add_raw_records([5], 'alpha'))
335
transport = self.get_transport()
336
access = _PackAccess({"FOO":(transport, 'packfile'),
337
"FOOBAR":(transport, 'pack2'),
338
"BAZ":(transport, 'pack3')})
339
self.assertEqual(['1234567890', '12345', 'alpha'],
340
list(access.get_raw_records(memos)))
341
self.assertEqual(['1234567890'],
342
list(access.get_raw_records(memos[0:1])))
343
self.assertEqual(['12345'],
344
list(access.get_raw_records(memos[1:2])))
345
self.assertEqual(['alpha'],
346
list(access.get_raw_records(memos[2:3])))
347
self.assertEqual(['1234567890', 'alpha'],
348
list(access.get_raw_records(memos[0:1] + memos[2:3])))
350
def test_set_writer(self):
351
"""The writer should be settable post construction."""
352
access = _PackAccess({})
353
transport = self.get_transport()
354
packname = 'packfile'
356
def write_data(bytes):
357
transport.append_bytes(packname, bytes)
358
writer = pack.ContainerWriter(write_data)
360
access.set_writer(writer, index, (transport, packname))
361
memos = access.add_raw_records([10], '1234567890')
363
self.assertEqual(['1234567890'], list(access.get_raw_records(memos)))
366
class LowLevelKnitDataTests(TestCase):
368
def create_gz_content(self, text):
370
gz_file = gzip.GzipFile(mode='wb', fileobj=sio)
373
return sio.getvalue()
375
def test_valid_knit_data(self):
376
sha1sum = sha.new('foo\nbar\n').hexdigest()
377
gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'
382
transport = MockTransport([gz_txt])
383
access = _KnitAccess(transport, 'filename', None, None, False, False)
384
data = _KnitData(access=access)
385
records = [('rev-id-1', (None, 0, len(gz_txt)))]
387
contents = data.read_records(records)
388
self.assertEqual({'rev-id-1':(['foo\n', 'bar\n'], sha1sum)}, contents)
390
raw_contents = list(data.read_records_iter_raw(records))
391
self.assertEqual([('rev-id-1', gz_txt)], raw_contents)
393
def test_not_enough_lines(self):
394
sha1sum = sha.new('foo\n').hexdigest()
395
# record says 2 lines data says 1
396
gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'
400
transport = MockTransport([gz_txt])
401
access = _KnitAccess(transport, 'filename', None, None, False, False)
402
data = _KnitData(access=access)
403
records = [('rev-id-1', (None, 0, len(gz_txt)))]
404
self.assertRaises(errors.KnitCorrupt, data.read_records, records)
406
# read_records_iter_raw won't detect that sort of mismatch/corruption
407
raw_contents = list(data.read_records_iter_raw(records))
408
self.assertEqual([('rev-id-1', gz_txt)], raw_contents)
410
def test_too_many_lines(self):
411
sha1sum = sha.new('foo\nbar\n').hexdigest()
412
# record says 1 lines data says 2
413
gz_txt = self.create_gz_content('version rev-id-1 1 %s\n'
418
transport = MockTransport([gz_txt])
419
access = _KnitAccess(transport, 'filename', None, None, False, False)
420
data = _KnitData(access=access)
421
records = [('rev-id-1', (None, 0, len(gz_txt)))]
422
self.assertRaises(errors.KnitCorrupt, data.read_records, records)
424
# read_records_iter_raw won't detect that sort of mismatch/corruption
425
raw_contents = list(data.read_records_iter_raw(records))
426
self.assertEqual([('rev-id-1', gz_txt)], raw_contents)
428
def test_mismatched_version_id(self):
429
sha1sum = sha.new('foo\nbar\n').hexdigest()
430
gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'
435
transport = MockTransport([gz_txt])
436
access = _KnitAccess(transport, 'filename', None, None, False, False)
437
data = _KnitData(access=access)
438
# We are asking for rev-id-2, but the data is rev-id-1
439
records = [('rev-id-2', (None, 0, len(gz_txt)))]
440
self.assertRaises(errors.KnitCorrupt, data.read_records, records)
442
# read_records_iter_raw will notice if we request the wrong version.
443
self.assertRaises(errors.KnitCorrupt, list,
444
data.read_records_iter_raw(records))
446
def test_uncompressed_data(self):
447
sha1sum = sha.new('foo\nbar\n').hexdigest()
448
txt = ('version rev-id-1 2 %s\n'
453
transport = MockTransport([txt])
454
access = _KnitAccess(transport, 'filename', None, None, False, False)
455
data = _KnitData(access=access)
456
records = [('rev-id-1', (None, 0, len(txt)))]
458
# We don't have valid gzip data ==> corrupt
459
self.assertRaises(errors.KnitCorrupt, data.read_records, records)
461
# read_records_iter_raw will notice the bad data
462
self.assertRaises(errors.KnitCorrupt, list,
463
data.read_records_iter_raw(records))
465
def test_corrupted_data(self):
466
sha1sum = sha.new('foo\nbar\n').hexdigest()
467
gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'
472
# Change 2 bytes in the middle to \xff
473
gz_txt = gz_txt[:10] + '\xff\xff' + gz_txt[12:]
474
transport = MockTransport([gz_txt])
475
access = _KnitAccess(transport, 'filename', None, None, False, False)
476
data = _KnitData(access=access)
477
records = [('rev-id-1', (None, 0, len(gz_txt)))]
479
self.assertRaises(errors.KnitCorrupt, data.read_records, records)
481
# read_records_iter_raw will notice if we request the wrong version.
482
self.assertRaises(errors.KnitCorrupt, list,
483
data.read_records_iter_raw(records))
486
class LowLevelKnitIndexTests(TestCase):
488
def get_knit_index(self, *args, **kwargs):
489
orig = knit._load_data
491
knit._load_data = orig
492
self.addCleanup(reset)
493
from bzrlib._knit_load_data_py import _load_data_py
494
knit._load_data = _load_data_py
495
return _KnitIndex(*args, **kwargs)
497
def test_no_such_file(self):
498
transport = MockTransport()
500
self.assertRaises(NoSuchFile, self.get_knit_index,
501
transport, "filename", "r")
502
self.assertRaises(NoSuchFile, self.get_knit_index,
503
transport, "filename", "w", create=False)
505
def test_create_file(self):
506
transport = MockTransport()
508
index = self.get_knit_index(transport, "filename", "w",
509
file_mode="wb", create=True)
511
("put_bytes_non_atomic",
512
("filename", index.HEADER), {"mode": "wb"}),
513
transport.calls.pop(0))
515
def test_delay_create_file(self):
516
transport = MockTransport()
518
index = self.get_knit_index(transport, "filename", "w",
519
create=True, file_mode="wb", create_parent_dir=True,
520
delay_create=True, dir_mode=0777)
521
self.assertEqual([], transport.calls)
523
index.add_versions([])
524
name, (filename, f), kwargs = transport.calls.pop(0)
525
self.assertEqual("put_file_non_atomic", name)
527
{"dir_mode": 0777, "create_parent_dir": True, "mode": "wb"},
529
self.assertEqual("filename", filename)
530
self.assertEqual(index.HEADER, f.read())
532
index.add_versions([])
533
self.assertEqual(("append_bytes", ("filename", ""), {}),
534
transport.calls.pop(0))
536
def test_read_utf8_version_id(self):
537
unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
538
utf8_revision_id = unicode_revision_id.encode('utf-8')
539
transport = MockTransport([
541
'%s option 0 1 :' % (utf8_revision_id,)
543
index = self.get_knit_index(transport, "filename", "r")
544
# _KnitIndex is a private class, and deals in utf8 revision_ids, not
545
# Unicode revision_ids.
546
self.assertTrue(index.has_version(utf8_revision_id))
547
self.assertFalse(index.has_version(unicode_revision_id))
549
def test_read_utf8_parents(self):
550
unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
551
utf8_revision_id = unicode_revision_id.encode('utf-8')
552
transport = MockTransport([
554
"version option 0 1 .%s :" % (utf8_revision_id,)
556
index = self.get_knit_index(transport, "filename", "r")
557
self.assertEqual((utf8_revision_id,),
558
index.get_parents_with_ghosts("version"))
560
def test_read_ignore_corrupted_lines(self):
561
transport = MockTransport([
564
"corrupted options 0 1 .b .c ",
565
"version options 0 1 :"
567
index = self.get_knit_index(transport, "filename", "r")
568
self.assertEqual(1, index.num_versions())
569
self.assertTrue(index.has_version("version"))
571
def test_read_corrupted_header(self):
572
transport = MockTransport(['not a bzr knit index header\n'])
573
self.assertRaises(KnitHeaderError,
574
self.get_knit_index, transport, "filename", "r")
576
def test_read_duplicate_entries(self):
577
transport = MockTransport([
579
"parent options 0 1 :",
580
"version options1 0 1 0 :",
581
"version options2 1 2 .other :",
582
"version options3 3 4 0 .other :"
584
index = self.get_knit_index(transport, "filename", "r")
585
self.assertEqual(2, index.num_versions())
586
# check that the index used is the first one written. (Specific
587
# to KnitIndex style indices.
588
self.assertEqual("1", index._version_list_to_index(["version"]))
589
self.assertEqual((None, 3, 4), index.get_position("version"))
590
self.assertEqual(["options3"], index.get_options("version"))
591
self.assertEqual(("parent", "other"),
592
index.get_parents_with_ghosts("version"))
594
def test_read_compressed_parents(self):
595
transport = MockTransport([
599
"c option 0 1 1 0 :",
601
index = self.get_knit_index(transport, "filename", "r")
602
self.assertEqual(["a"], index.get_parents("b"))
603
self.assertEqual(["b", "a"], index.get_parents("c"))
605
def test_write_utf8_version_id(self):
606
unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
607
utf8_revision_id = unicode_revision_id.encode('utf-8')
608
transport = MockTransport([
611
index = self.get_knit_index(transport, "filename", "r")
612
index.add_version(utf8_revision_id, ["option"], (None, 0, 1), [])
613
self.assertEqual(("append_bytes", ("filename",
614
"\n%s option 0 1 :" % (utf8_revision_id,)),
616
transport.calls.pop(0))
618
def test_write_utf8_parents(self):
619
unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
620
utf8_revision_id = unicode_revision_id.encode('utf-8')
621
transport = MockTransport([
624
index = self.get_knit_index(transport, "filename", "r")
625
index.add_version("version", ["option"], (None, 0, 1), [utf8_revision_id])
626
self.assertEqual(("append_bytes", ("filename",
627
"\nversion option 0 1 .%s :" % (utf8_revision_id,)),
629
transport.calls.pop(0))
631
def test_get_graph(self):
632
transport = MockTransport()
633
index = self.get_knit_index(transport, "filename", "w", create=True)
634
self.assertEqual([], index.get_graph())
636
index.add_version("a", ["option"], (None, 0, 1), ["b"])
637
self.assertEqual([("a", ("b",))], index.get_graph())
639
index.add_version("c", ["option"], (None, 0, 1), ["d"])
640
self.assertEqual([("a", ("b",)), ("c", ("d",))],
641
sorted(index.get_graph()))
643
def test_get_ancestry(self):
644
transport = MockTransport([
647
"b option 0 1 0 .e :",
648
"c option 0 1 1 0 :",
649
"d option 0 1 2 .f :"
651
index = self.get_knit_index(transport, "filename", "r")
653
self.assertEqual([], index.get_ancestry([]))
654
self.assertEqual(["a"], index.get_ancestry(["a"]))
655
self.assertEqual(["a", "b"], index.get_ancestry(["b"]))
656
self.assertEqual(["a", "b", "c"], index.get_ancestry(["c"]))
657
self.assertEqual(["a", "b", "c", "d"], index.get_ancestry(["d"]))
658
self.assertEqual(["a", "b"], index.get_ancestry(["a", "b"]))
659
self.assertEqual(["a", "b", "c"], index.get_ancestry(["a", "c"]))
661
self.assertRaises(RevisionNotPresent, index.get_ancestry, ["e"])
663
def test_get_ancestry_with_ghosts(self):
664
transport = MockTransport([
667
"b option 0 1 0 .e :",
668
"c option 0 1 0 .f .g :",
669
"d option 0 1 2 .h .j .k :"
671
index = self.get_knit_index(transport, "filename", "r")
673
self.assertEqual([], index.get_ancestry_with_ghosts([]))
674
self.assertEqual(["a"], index.get_ancestry_with_ghosts(["a"]))
675
self.assertEqual(["a", "e", "b"],
676
index.get_ancestry_with_ghosts(["b"]))
677
self.assertEqual(["a", "g", "f", "c"],
678
index.get_ancestry_with_ghosts(["c"]))
679
self.assertEqual(["a", "g", "f", "c", "k", "j", "h", "d"],
680
index.get_ancestry_with_ghosts(["d"]))
681
self.assertEqual(["a", "e", "b"],
682
index.get_ancestry_with_ghosts(["a", "b"]))
683
self.assertEqual(["a", "g", "f", "c"],
684
index.get_ancestry_with_ghosts(["a", "c"]))
686
["a", "g", "f", "c", "e", "b", "k", "j", "h", "d"],
687
index.get_ancestry_with_ghosts(["b", "d"]))
689
self.assertRaises(RevisionNotPresent,
690
index.get_ancestry_with_ghosts, ["e"])
692
def test_iter_parents(self):
693
transport = MockTransport()
694
index = self.get_knit_index(transport, "filename", "w", create=True)
696
index.add_version('r0', ['option'], (None, 0, 1), [])
698
index.add_version('r1', ['option'], (None, 0, 1), ['r0'])
700
index.add_version('r2', ['option'], (None, 0, 1), ['r1', 'r0'])
702
# cases: each sample data individually:
703
self.assertEqual(set([('r0', ())]),
704
set(index.iter_parents(['r0'])))
705
self.assertEqual(set([('r1', ('r0', ))]),
706
set(index.iter_parents(['r1'])))
707
self.assertEqual(set([('r2', ('r1', 'r0'))]),
708
set(index.iter_parents(['r2'])))
709
# no nodes returned for a missing node
710
self.assertEqual(set(),
711
set(index.iter_parents(['missing'])))
712
# 1 node returned with missing nodes skipped
713
self.assertEqual(set([('r1', ('r0', ))]),
714
set(index.iter_parents(['ghost1', 'r1', 'ghost'])))
716
self.assertEqual(set([('r0', ()), ('r1', ('r0', ))]),
717
set(index.iter_parents(['r0', 'r1'])))
718
# 2 nodes returned, missing skipped
719
self.assertEqual(set([('r0', ()), ('r1', ('r0', ))]),
720
set(index.iter_parents(['a', 'r0', 'b', 'r1', 'c'])))
722
def test_num_versions(self):
723
transport = MockTransport([
726
index = self.get_knit_index(transport, "filename", "r")
728
self.assertEqual(0, index.num_versions())
729
self.assertEqual(0, len(index))
731
index.add_version("a", ["option"], (None, 0, 1), [])
732
self.assertEqual(1, index.num_versions())
733
self.assertEqual(1, len(index))
735
index.add_version("a", ["option2"], (None, 1, 2), [])
736
self.assertEqual(1, index.num_versions())
737
self.assertEqual(1, len(index))
739
index.add_version("b", ["option"], (None, 0, 1), [])
740
self.assertEqual(2, index.num_versions())
741
self.assertEqual(2, len(index))
743
def test_get_versions(self):
744
transport = MockTransport([
747
index = self.get_knit_index(transport, "filename", "r")
749
self.assertEqual([], index.get_versions())
751
index.add_version("a", ["option"], (None, 0, 1), [])
752
self.assertEqual(["a"], index.get_versions())
754
index.add_version("a", ["option"], (None, 0, 1), [])
755
self.assertEqual(["a"], index.get_versions())
757
index.add_version("b", ["option"], (None, 0, 1), [])
758
self.assertEqual(["a", "b"], index.get_versions())
760
def test_add_version(self):
761
transport = MockTransport([
764
index = self.get_knit_index(transport, "filename", "r")
766
index.add_version("a", ["option"], (None, 0, 1), ["b"])
767
self.assertEqual(("append_bytes",
768
("filename", "\na option 0 1 .b :"),
769
{}), transport.calls.pop(0))
770
self.assertTrue(index.has_version("a"))
771
self.assertEqual(1, index.num_versions())
772
self.assertEqual((None, 0, 1), index.get_position("a"))
773
self.assertEqual(["option"], index.get_options("a"))
774
self.assertEqual(("b",), index.get_parents_with_ghosts("a"))
776
index.add_version("a", ["opt"], (None, 1, 2), ["c"])
777
self.assertEqual(("append_bytes",
778
("filename", "\na opt 1 2 .c :"),
779
{}), transport.calls.pop(0))
780
self.assertTrue(index.has_version("a"))
781
self.assertEqual(1, index.num_versions())
782
self.assertEqual((None, 1, 2), index.get_position("a"))
783
self.assertEqual(["opt"], index.get_options("a"))
784
self.assertEqual(("c",), index.get_parents_with_ghosts("a"))
786
index.add_version("b", ["option"], (None, 2, 3), ["a"])
787
self.assertEqual(("append_bytes",
788
("filename", "\nb option 2 3 0 :"),
789
{}), transport.calls.pop(0))
790
self.assertTrue(index.has_version("b"))
791
self.assertEqual(2, index.num_versions())
792
self.assertEqual((None, 2, 3), index.get_position("b"))
793
self.assertEqual(["option"], index.get_options("b"))
794
self.assertEqual(("a",), index.get_parents_with_ghosts("b"))
796
def test_add_versions(self):
797
transport = MockTransport([
800
index = self.get_knit_index(transport, "filename", "r")
803
("a", ["option"], (None, 0, 1), ["b"]),
804
("a", ["opt"], (None, 1, 2), ["c"]),
805
("b", ["option"], (None, 2, 3), ["a"])
807
self.assertEqual(("append_bytes", ("filename",
808
"\na option 0 1 .b :"
811
), {}), transport.calls.pop(0))
812
self.assertTrue(index.has_version("a"))
813
self.assertTrue(index.has_version("b"))
814
self.assertEqual(2, index.num_versions())
815
self.assertEqual((None, 1, 2), index.get_position("a"))
816
self.assertEqual((None, 2, 3), index.get_position("b"))
817
self.assertEqual(["opt"], index.get_options("a"))
818
self.assertEqual(["option"], index.get_options("b"))
819
self.assertEqual(("c",), index.get_parents_with_ghosts("a"))
820
self.assertEqual(("a",), index.get_parents_with_ghosts("b"))
822
def test_add_versions_random_id_is_accepted(self):
823
transport = MockTransport([
826
index = self.get_knit_index(transport, "filename", "r")
829
("a", ["option"], (None, 0, 1), ["b"]),
830
("a", ["opt"], (None, 1, 2), ["c"]),
831
("b", ["option"], (None, 2, 3), ["a"])
834
def test_delay_create_and_add_versions(self):
835
transport = MockTransport()
837
index = self.get_knit_index(transport, "filename", "w",
838
create=True, file_mode="wb", create_parent_dir=True,
839
delay_create=True, dir_mode=0777)
840
self.assertEqual([], transport.calls)
843
("a", ["option"], (None, 0, 1), ["b"]),
844
("a", ["opt"], (None, 1, 2), ["c"]),
845
("b", ["option"], (None, 2, 3), ["a"])
847
name, (filename, f), kwargs = transport.calls.pop(0)
848
self.assertEqual("put_file_non_atomic", name)
850
{"dir_mode": 0777, "create_parent_dir": True, "mode": "wb"},
852
self.assertEqual("filename", filename)
855
"\na option 0 1 .b :"
857
"\nb option 2 3 0 :",
860
def test_has_version(self):
861
transport = MockTransport([
865
index = self.get_knit_index(transport, "filename", "r")
867
self.assertTrue(index.has_version("a"))
868
self.assertFalse(index.has_version("b"))
870
def test_get_position(self):
871
transport = MockTransport([
876
index = self.get_knit_index(transport, "filename", "r")
878
self.assertEqual((None, 0, 1), index.get_position("a"))
879
self.assertEqual((None, 1, 2), index.get_position("b"))
881
def test_get_method(self):
882
transport = MockTransport([
884
"a fulltext,unknown 0 1 :",
885
"b unknown,line-delta 1 2 :",
888
index = self.get_knit_index(transport, "filename", "r")
890
self.assertEqual("fulltext", index.get_method("a"))
891
self.assertEqual("line-delta", index.get_method("b"))
892
self.assertRaises(errors.KnitIndexUnknownMethod, index.get_method, "c")
894
def test_get_options(self):
895
transport = MockTransport([
900
index = self.get_knit_index(transport, "filename", "r")
902
self.assertEqual(["opt1"], index.get_options("a"))
903
self.assertEqual(["opt2", "opt3"], index.get_options("b"))
905
def test_get_parents(self):
906
transport = MockTransport([
909
"b option 1 2 0 .c :",
910
"c option 1 2 1 0 .e :"
912
index = self.get_knit_index(transport, "filename", "r")
914
self.assertEqual([], index.get_parents("a"))
915
self.assertEqual(["a", "c"], index.get_parents("b"))
916
self.assertEqual(["b", "a"], index.get_parents("c"))
918
def test_get_parents_with_ghosts(self):
919
transport = MockTransport([
922
"b option 1 2 0 .c :",
923
"c option 1 2 1 0 .e :"
925
index = self.get_knit_index(transport, "filename", "r")
927
self.assertEqual((), index.get_parents_with_ghosts("a"))
928
self.assertEqual(("a", "c"), index.get_parents_with_ghosts("b"))
929
self.assertEqual(("b", "a", "e"),
930
index.get_parents_with_ghosts("c"))
932
def test_check_versions_present(self):
933
transport = MockTransport([
938
index = self.get_knit_index(transport, "filename", "r")
940
check = index.check_versions_present
946
self.assertRaises(RevisionNotPresent, check, ["c"])
947
self.assertRaises(RevisionNotPresent, check, ["a", "b", "c"])
949
def test_impossible_parent(self):
950
"""Test we get KnitCorrupt if the parent couldn't possibly exist."""
951
transport = MockTransport([
954
"b option 0 1 4 :" # We don't have a 4th record
957
self.assertRaises(errors.KnitCorrupt,
958
self.get_knit_index, transport, 'filename', 'r')
960
if (str(e) == ('exceptions must be strings, classes, or instances,'
961
' not exceptions.IndexError')
962
and sys.version_info[0:2] >= (2,5)):
963
self.knownFailure('Pyrex <0.9.5 fails with TypeError when'
964
' raising new style exceptions with python'
969
def test_corrupted_parent(self):
970
transport = MockTransport([
974
"c option 0 1 1v :", # Can't have a parent of '1v'
977
self.assertRaises(errors.KnitCorrupt,
978
self.get_knit_index, transport, 'filename', 'r')
980
if (str(e) == ('exceptions must be strings, classes, or instances,'
981
' not exceptions.ValueError')
982
and sys.version_info[0:2] >= (2,5)):
983
self.knownFailure('Pyrex <0.9.5 fails with TypeError when'
984
' raising new style exceptions with python'
989
def test_corrupted_parent_in_list(self):
990
transport = MockTransport([
994
"c option 0 1 1 v :", # Can't have a parent of 'v'
997
self.assertRaises(errors.KnitCorrupt,
998
self.get_knit_index, transport, 'filename', 'r')
1000
if (str(e) == ('exceptions must be strings, classes, or instances,'
1001
' not exceptions.ValueError')
1002
and sys.version_info[0:2] >= (2,5)):
1003
self.knownFailure('Pyrex <0.9.5 fails with TypeError when'
1004
' raising new style exceptions with python'
1009
def test_invalid_position(self):
1010
transport = MockTransport([
1015
self.assertRaises(errors.KnitCorrupt,
1016
self.get_knit_index, transport, 'filename', 'r')
1017
except TypeError, e:
1018
if (str(e) == ('exceptions must be strings, classes, or instances,'
1019
' not exceptions.ValueError')
1020
and sys.version_info[0:2] >= (2,5)):
1021
self.knownFailure('Pyrex <0.9.5 fails with TypeError when'
1022
' raising new style exceptions with python'
1027
def test_invalid_size(self):
1028
transport = MockTransport([
1033
self.assertRaises(errors.KnitCorrupt,
1034
self.get_knit_index, transport, 'filename', 'r')
1035
except TypeError, e:
1036
if (str(e) == ('exceptions must be strings, classes, or instances,'
1037
' not exceptions.ValueError')
1038
and sys.version_info[0:2] >= (2,5)):
1039
self.knownFailure('Pyrex <0.9.5 fails with TypeError when'
1040
' raising new style exceptions with python'
1045
def test_short_line(self):
1046
transport = MockTransport([
1049
"b option 10 10 0", # This line isn't terminated, ignored
1051
index = self.get_knit_index(transport, "filename", "r")
1052
self.assertEqual(['a'], index.get_versions())
1054
def test_skip_incomplete_record(self):
1055
# A line with bogus data should just be skipped
1056
transport = MockTransport([
1059
"b option 10 10 0", # This line isn't terminated, ignored
1060
"c option 20 10 0 :", # Properly terminated, and starts with '\n'
1062
index = self.get_knit_index(transport, "filename", "r")
1063
self.assertEqual(['a', 'c'], index.get_versions())
1065
def test_trailing_characters(self):
1066
# A line with bogus data should just be skipped
1067
transport = MockTransport([
1070
"b option 10 10 0 :a", # This line has extra trailing characters
1071
"c option 20 10 0 :", # Properly terminated, and starts with '\n'
1073
index = self.get_knit_index(transport, "filename", "r")
1074
self.assertEqual(['a', 'c'], index.get_versions())
1077
class LowLevelKnitIndexTests_c(LowLevelKnitIndexTests):
1079
_test_needs_features = [CompiledKnitFeature]
1081
def get_knit_index(self, *args, **kwargs):
1082
orig = knit._load_data
1084
knit._load_data = orig
1085
self.addCleanup(reset)
1086
from bzrlib._knit_load_data_c import _load_data_c
1087
knit._load_data = _load_data_c
1088
return _KnitIndex(*args, **kwargs)
1092
class KnitTests(TestCaseWithTransport):
1093
"""Class containing knit test helper routines."""
1095
def make_test_knit(self, annotate=False, delay_create=False, index=None,
1098
factory = KnitPlainFactory()
1101
return KnitVersionedFile(name, get_transport('.'), access_mode='w',
1102
factory=factory, create=True,
1103
delay_create=delay_create, index=index)
1105
def assertRecordContentEqual(self, knit, version_id, candidate_content):
1106
"""Assert that some raw record content matches the raw record content
1107
for a particular version_id in the given knit.
1109
index_memo = knit._index.get_position(version_id)
1110
record = (version_id, index_memo)
1111
[(_, expected_content)] = list(knit._data.read_records_iter_raw([record]))
1112
self.assertEqual(expected_content, candidate_content)
1115
class BasicKnitTests(KnitTests):
1117
def add_stock_one_and_one_a(self, k):
1118
k.add_lines('text-1', [], split_lines(TEXT_1))
1119
k.add_lines('text-1a', ['text-1'], split_lines(TEXT_1A))
1121
def test_knit_constructor(self):
1122
"""Construct empty k"""
1123
self.make_test_knit()
1125
def test_make_explicit_index(self):
1126
"""We can supply an index to use."""
1127
knit = KnitVersionedFile('test', get_transport('.'),
1128
index='strangelove')
1129
self.assertEqual(knit._index, 'strangelove')
1131
def test_knit_add(self):
1132
"""Store one text in knit and retrieve"""
1133
k = self.make_test_knit()
1134
k.add_lines('text-1', [], split_lines(TEXT_1))
1135
self.assertTrue(k.has_version('text-1'))
1136
self.assertEqualDiff(''.join(k.get_lines('text-1')), TEXT_1)
1138
def test_newline_empty_lines(self):
1139
# ensure that ["\n"] round trips ok.
1140
knit = self.make_test_knit()
1141
knit.add_lines('a', [], ["\n"])
1142
knit.add_lines_with_ghosts('b', [], ["\n"])
1143
self.assertEqual(["\n"], knit.get_lines('a'))
1144
self.assertEqual(["\n"], knit.get_lines('b'))
1145
self.assertEqual(['fulltext'], knit._index.get_options('a'))
1146
self.assertEqual(['fulltext'], knit._index.get_options('b'))
1147
knit.add_lines('c', ['a'], ["\n"])
1148
knit.add_lines_with_ghosts('d', ['b'], ["\n"])
1149
self.assertEqual(["\n"], knit.get_lines('c'))
1150
self.assertEqual(["\n"], knit.get_lines('d'))
1151
self.assertEqual(['line-delta'], knit._index.get_options('c'))
1152
self.assertEqual(['line-delta'], knit._index.get_options('d'))
1154
def test_empty_lines(self):
1155
# bizarrely, [] is not listed as having no-eol.
1156
knit = self.make_test_knit()
1157
knit.add_lines('a', [], [])
1158
knit.add_lines_with_ghosts('b', [], [])
1159
self.assertEqual([], knit.get_lines('a'))
1160
self.assertEqual([], knit.get_lines('b'))
1161
self.assertEqual(['fulltext'], knit._index.get_options('a'))
1162
self.assertEqual(['fulltext'], knit._index.get_options('b'))
1163
knit.add_lines('c', ['a'], [])
1164
knit.add_lines_with_ghosts('d', ['b'], [])
1165
self.assertEqual([], knit.get_lines('c'))
1166
self.assertEqual([], knit.get_lines('d'))
1167
self.assertEqual(['line-delta'], knit._index.get_options('c'))
1168
self.assertEqual(['line-delta'], knit._index.get_options('d'))
1170
def test_knit_reload(self):
1171
# test that the content in a reloaded knit is correct
1172
k = self.make_test_knit()
1173
k.add_lines('text-1', [], split_lines(TEXT_1))
1175
k2 = KnitVersionedFile('test', get_transport('.'), access_mode='r', factory=KnitPlainFactory(), create=True)
1176
self.assertTrue(k2.has_version('text-1'))
1177
self.assertEqualDiff(''.join(k2.get_lines('text-1')), TEXT_1)
1179
def test_knit_several(self):
1180
"""Store several texts in a knit"""
1181
k = self.make_test_knit()
1182
k.add_lines('text-1', [], split_lines(TEXT_1))
1183
k.add_lines('text-2', [], split_lines(TEXT_2))
1184
self.assertEqualDiff(''.join(k.get_lines('text-1')), TEXT_1)
1185
self.assertEqualDiff(''.join(k.get_lines('text-2')), TEXT_2)
1187
def test_repeated_add(self):
1188
"""Knit traps attempt to replace existing version"""
1189
k = self.make_test_knit()
1190
k.add_lines('text-1', [], split_lines(TEXT_1))
1191
self.assertRaises(RevisionAlreadyPresent,
1193
'text-1', [], split_lines(TEXT_1))
1195
def test_empty(self):
1196
k = self.make_test_knit(True)
1197
k.add_lines('text-1', [], [])
1198
self.assertEquals(k.get_lines('text-1'), [])
1200
def test_incomplete(self):
1201
"""Test if texts without a ending line-end can be inserted and
1203
k = KnitVersionedFile('test', get_transport('.'), delta=False, create=True)
1204
k.add_lines('text-1', [], ['a\n', 'b' ])
1205
k.add_lines('text-2', ['text-1'], ['a\rb\n', 'b\n'])
1206
# reopening ensures maximum room for confusion
1207
k = KnitVersionedFile('test', get_transport('.'), delta=False, create=True)
1208
self.assertEquals(k.get_lines('text-1'), ['a\n', 'b' ])
1209
self.assertEquals(k.get_lines('text-2'), ['a\rb\n', 'b\n'])
1211
def test_delta(self):
1212
"""Expression of knit delta as lines"""
1213
k = self.make_test_knit()
1214
td = list(line_delta(TEXT_1.splitlines(True),
1215
TEXT_1A.splitlines(True)))
1216
self.assertEqualDiff(''.join(td), delta_1_1a)
1217
out = apply_line_delta(TEXT_1.splitlines(True), td)
1218
self.assertEqualDiff(''.join(out), TEXT_1A)
1220
def test_add_with_parents(self):
1221
"""Store in knit with parents"""
1222
k = self.make_test_knit()
1223
self.add_stock_one_and_one_a(k)
1224
self.assertEqual({'text-1':(), 'text-1a':('text-1',)},
1225
k.get_parent_map(['text-1', 'text-1a']))
1227
def test_ancestry(self):
1228
"""Store in knit with parents"""
1229
k = self.make_test_knit()
1230
self.add_stock_one_and_one_a(k)
1231
self.assertEquals(set(k.get_ancestry(['text-1a'])), set(['text-1a', 'text-1']))
1233
def test_add_delta(self):
1234
"""Store in knit with parents"""
1235
k = KnitVersionedFile('test', get_transport('.'), factory=KnitPlainFactory(),
1236
delta=True, create=True)
1237
self.add_stock_one_and_one_a(k)
1239
self.assertEqualDiff(''.join(k.get_lines('text-1a')), TEXT_1A)
1241
def test_add_delta_knit_graph_index(self):
1242
"""Does adding work with a KnitGraphIndex."""
1243
index = InMemoryGraphIndex(2)
1244
knit_index = KnitGraphIndex(index, add_callback=index.add_nodes,
1246
k = KnitVersionedFile('test', get_transport('.'),
1247
delta=True, create=True, index=knit_index)
1248
self.add_stock_one_and_one_a(k)
1250
self.assertEqualDiff(''.join(k.get_lines('text-1a')), TEXT_1A)
1251
# check the index had the right data added.
1252
self.assertEqual(set([
1253
(index, ('text-1', ), ' 0 127', ((), ())),
1254
(index, ('text-1a', ), ' 127 140', ((('text-1', ),), (('text-1', ),))),
1255
]), set(index.iter_all_entries()))
1256
# we should not have a .kndx file
1257
self.assertFalse(get_transport('.').has('test.kndx'))
1259
def test_annotate(self):
1261
k = KnitVersionedFile('knit', get_transport('.'), factory=KnitAnnotateFactory(),
1262
delta=True, create=True)
1263
self.insert_and_test_small_annotate(k)
1265
def insert_and_test_small_annotate(self, k):
1266
"""test annotation with k works correctly."""
1267
k.add_lines('text-1', [], ['a\n', 'b\n'])
1268
k.add_lines('text-2', ['text-1'], ['a\n', 'c\n'])
1270
origins = k.annotate('text-2')
1271
self.assertEquals(origins[0], ('text-1', 'a\n'))
1272
self.assertEquals(origins[1], ('text-2', 'c\n'))
1274
def test_annotate_fulltext(self):
1276
k = KnitVersionedFile('knit', get_transport('.'), factory=KnitAnnotateFactory(),
1277
delta=False, create=True)
1278
self.insert_and_test_small_annotate(k)
1280
def test_annotate_merge_1(self):
1281
k = self.make_test_knit(True)
1282
k.add_lines('text-a1', [], ['a\n', 'b\n'])
1283
k.add_lines('text-a2', [], ['d\n', 'c\n'])
1284
k.add_lines('text-am', ['text-a1', 'text-a2'], ['d\n', 'b\n'])
1285
origins = k.annotate('text-am')
1286
self.assertEquals(origins[0], ('text-a2', 'd\n'))
1287
self.assertEquals(origins[1], ('text-a1', 'b\n'))
1289
def test_annotate_merge_2(self):
1290
k = self.make_test_knit(True)
1291
k.add_lines('text-a1', [], ['a\n', 'b\n', 'c\n'])
1292
k.add_lines('text-a2', [], ['x\n', 'y\n', 'z\n'])
1293
k.add_lines('text-am', ['text-a1', 'text-a2'], ['a\n', 'y\n', 'c\n'])
1294
origins = k.annotate('text-am')
1295
self.assertEquals(origins[0], ('text-a1', 'a\n'))
1296
self.assertEquals(origins[1], ('text-a2', 'y\n'))
1297
self.assertEquals(origins[2], ('text-a1', 'c\n'))
1299
def test_annotate_merge_9(self):
1300
k = self.make_test_knit(True)
1301
k.add_lines('text-a1', [], ['a\n', 'b\n', 'c\n'])
1302
k.add_lines('text-a2', [], ['x\n', 'y\n', 'z\n'])
1303
k.add_lines('text-am', ['text-a1', 'text-a2'], ['k\n', 'y\n', 'c\n'])
1304
origins = k.annotate('text-am')
1305
self.assertEquals(origins[0], ('text-am', 'k\n'))
1306
self.assertEquals(origins[1], ('text-a2', 'y\n'))
1307
self.assertEquals(origins[2], ('text-a1', 'c\n'))
1309
def test_annotate_merge_3(self):
1310
k = self.make_test_knit(True)
1311
k.add_lines('text-a1', [], ['a\n', 'b\n', 'c\n'])
1312
k.add_lines('text-a2', [] ,['x\n', 'y\n', 'z\n'])
1313
k.add_lines('text-am', ['text-a1', 'text-a2'], ['k\n', 'y\n', 'z\n'])
1314
origins = k.annotate('text-am')
1315
self.assertEquals(origins[0], ('text-am', 'k\n'))
1316
self.assertEquals(origins[1], ('text-a2', 'y\n'))
1317
self.assertEquals(origins[2], ('text-a2', 'z\n'))
1319
def test_annotate_merge_4(self):
1320
k = self.make_test_knit(True)
1321
k.add_lines('text-a1', [], ['a\n', 'b\n', 'c\n'])
1322
k.add_lines('text-a2', [], ['x\n', 'y\n', 'z\n'])
1323
k.add_lines('text-a3', ['text-a1'], ['a\n', 'b\n', 'p\n'])
1324
k.add_lines('text-am', ['text-a2', 'text-a3'], ['a\n', 'b\n', 'z\n'])
1325
origins = k.annotate('text-am')
1326
self.assertEquals(origins[0], ('text-a1', 'a\n'))
1327
self.assertEquals(origins[1], ('text-a1', 'b\n'))
1328
self.assertEquals(origins[2], ('text-a2', 'z\n'))
1330
def test_annotate_merge_5(self):
1331
k = self.make_test_knit(True)
1332
k.add_lines('text-a1', [], ['a\n', 'b\n', 'c\n'])
1333
k.add_lines('text-a2', [], ['d\n', 'e\n', 'f\n'])
1334
k.add_lines('text-a3', [], ['x\n', 'y\n', 'z\n'])
1335
k.add_lines('text-am',
1336
['text-a1', 'text-a2', 'text-a3'],
1337
['a\n', 'e\n', 'z\n'])
1338
origins = k.annotate('text-am')
1339
self.assertEquals(origins[0], ('text-a1', 'a\n'))
1340
self.assertEquals(origins[1], ('text-a2', 'e\n'))
1341
self.assertEquals(origins[2], ('text-a3', 'z\n'))
1343
def test_annotate_file_cherry_pick(self):
1344
k = self.make_test_knit(True)
1345
k.add_lines('text-1', [], ['a\n', 'b\n', 'c\n'])
1346
k.add_lines('text-2', ['text-1'], ['d\n', 'e\n', 'f\n'])
1347
k.add_lines('text-3', ['text-2', 'text-1'], ['a\n', 'b\n', 'c\n'])
1348
origins = k.annotate('text-3')
1349
self.assertEquals(origins[0], ('text-1', 'a\n'))
1350
self.assertEquals(origins[1], ('text-1', 'b\n'))
1351
self.assertEquals(origins[2], ('text-1', 'c\n'))
1353
def _test_join_with_factories(self, k1_factory, k2_factory):
1354
k1 = KnitVersionedFile('test1', get_transport('.'), factory=k1_factory, create=True)
1355
k1.add_lines('text-a', [], ['a1\n', 'a2\n', 'a3\n'])
1356
k1.add_lines('text-b', ['text-a'], ['a1\n', 'b2\n', 'a3\n'])
1357
k1.add_lines('text-c', [], ['c1\n', 'c2\n', 'c3\n'])
1358
k1.add_lines('text-d', ['text-c'], ['c1\n', 'd2\n', 'd3\n'])
1359
k1.add_lines('text-m', ['text-b', 'text-d'], ['a1\n', 'b2\n', 'd3\n'])
1360
k2 = KnitVersionedFile('test2', get_transport('.'), factory=k2_factory, create=True)
1361
count = k2.join(k1, version_ids=['text-m'])
1362
self.assertEquals(count, 5)
1363
self.assertTrue(k2.has_version('text-a'))
1364
self.assertTrue(k2.has_version('text-c'))
1365
origins = k2.annotate('text-m')
1366
self.assertEquals(origins[0], ('text-a', 'a1\n'))
1367
self.assertEquals(origins[1], ('text-b', 'b2\n'))
1368
self.assertEquals(origins[2], ('text-d', 'd3\n'))
1370
def test_knit_join_plain_to_plain(self):
1371
"""Test joining a plain knit with a plain knit."""
1372
self._test_join_with_factories(KnitPlainFactory(), KnitPlainFactory())
1374
def test_knit_join_anno_to_anno(self):
1375
"""Test joining an annotated knit with an annotated knit."""
1376
self._test_join_with_factories(None, None)
1378
def test_knit_join_anno_to_plain(self):
1379
"""Test joining an annotated knit with a plain knit."""
1380
self._test_join_with_factories(None, KnitPlainFactory())
1382
def test_knit_join_plain_to_anno(self):
1383
"""Test joining a plain knit with an annotated knit."""
1384
self._test_join_with_factories(KnitPlainFactory(), None)
1386
def test_reannotate(self):
1387
k1 = KnitVersionedFile('knit1', get_transport('.'),
1388
factory=KnitAnnotateFactory(), create=True)
1390
k1.add_lines('text-a', [], ['a\n', 'b\n'])
1392
k1.add_lines('text-b', ['text-a'], ['a\n', 'c\n'])
1394
k2 = KnitVersionedFile('test2', get_transport('.'),
1395
factory=KnitAnnotateFactory(), create=True)
1396
k2.join(k1, version_ids=['text-b'])
1399
k1.add_lines('text-X', ['text-b'], ['a\n', 'b\n'])
1401
k2.add_lines('text-c', ['text-b'], ['z\n', 'c\n'])
1403
k2.add_lines('text-Y', ['text-b'], ['b\n', 'c\n'])
1405
# test-c will have index 3
1406
k1.join(k2, version_ids=['text-c'])
1408
lines = k1.get_lines('text-c')
1409
self.assertEquals(lines, ['z\n', 'c\n'])
1411
origins = k1.annotate('text-c')
1412
self.assertEquals(origins[0], ('text-c', 'z\n'))
1413
self.assertEquals(origins[1], ('text-b', 'c\n'))
1415
def test_get_line_delta_texts(self):
1416
"""Make sure we can call get_texts on text with reused line deltas"""
1417
k1 = KnitVersionedFile('test1', get_transport('.'),
1418
factory=KnitPlainFactory(), create=True)
1423
parents = ['%d' % (t-1)]
1424
k1.add_lines('%d' % t, parents, ['hello\n'] * t)
1425
k1.get_texts(('%d' % t) for t in range(3))
1427
def test_iter_lines_reads_in_order(self):
1428
instrumented_t = get_transport('trace+memory:///')
1429
k1 = KnitVersionedFile('id', instrumented_t, create=True, delta=True)
1430
self.assertEqual([('get', 'id.kndx',)], instrumented_t._activity)
1431
# add texts with no required ordering
1432
k1.add_lines('base', [], ['text\n'])
1433
k1.add_lines('base2', [], ['text2\n'])
1435
# clear the logged activity, but preserve the list instance in case of
1436
# clones pointing at it.
1437
del instrumented_t._activity[:]
1438
# request a last-first iteration
1439
results = list(k1.iter_lines_added_or_present_in_versions(
1442
[('readv', 'id.knit', [(0, 87), (87, 89)], False, None)],
1443
instrumented_t._activity)
1444
self.assertEqual([('text\n', 'base'), ('text2\n', 'base2')], results)
1446
def test_create_empty_annotated(self):
1447
k1 = self.make_test_knit(True)
1449
k1.add_lines('text-a', [], ['a\n', 'b\n'])
1450
k2 = k1.create_empty('t', MemoryTransport())
1451
self.assertTrue(isinstance(k2.factory, KnitAnnotateFactory))
1452
self.assertEqual(k1.delta, k2.delta)
1453
# the generic test checks for empty content and file class
1455
def test_knit_format(self):
1456
# this tests that a new knit index file has the expected content
1457
# and that is writes the data we expect as records are added.
1458
knit = self.make_test_knit(True)
1459
# Now knit files are not created until we first add data to them
1460
self.assertFileEqual("# bzr knit index 8\n", 'test.kndx')
1461
knit.add_lines_with_ghosts('revid', ['a_ghost'], ['a\n'])
1462
self.assertFileEqual(
1463
"# bzr knit index 8\n"
1465
"revid fulltext 0 84 .a_ghost :",
1467
knit.add_lines_with_ghosts('revid2', ['revid'], ['a\n'])
1468
self.assertFileEqual(
1469
"# bzr knit index 8\n"
1470
"\nrevid fulltext 0 84 .a_ghost :"
1471
"\nrevid2 line-delta 84 82 0 :",
1473
# we should be able to load this file again
1474
knit = KnitVersionedFile('test', get_transport('.'), access_mode='r')
1475
self.assertEqual(['revid', 'revid2'], knit.versions())
1476
# write a short write to the file and ensure that its ignored
1477
indexfile = file('test.kndx', 'ab')
1478
indexfile.write('\nrevid3 line-delta 166 82 1 2 3 4 5 .phwoar:demo ')
1480
# we should be able to load this file again
1481
knit = KnitVersionedFile('test', get_transport('.'), access_mode='w')
1482
self.assertEqual(['revid', 'revid2'], knit.versions())
1483
# and add a revision with the same id the failed write had
1484
knit.add_lines('revid3', ['revid2'], ['a\n'])
1485
# and when reading it revid3 should now appear.
1486
knit = KnitVersionedFile('test', get_transport('.'), access_mode='r')
1487
self.assertEqual(['revid', 'revid2', 'revid3'], knit.versions())
1488
self.assertEqual({'revid3':('revid2',)}, knit.get_parent_map(['revid3']))
1490
def test_delay_create(self):
1491
"""Test that passing delay_create=True creates files late"""
1492
knit = self.make_test_knit(annotate=True, delay_create=True)
1493
self.failIfExists('test.knit')
1494
self.failIfExists('test.kndx')
1495
knit.add_lines_with_ghosts('revid', ['a_ghost'], ['a\n'])
1496
self.failUnlessExists('test.knit')
1497
self.assertFileEqual(
1498
"# bzr knit index 8\n"
1500
"revid fulltext 0 84 .a_ghost :",
1503
def test_create_parent_dir(self):
1504
"""create_parent_dir can create knits in nonexistant dirs"""
1505
# Has no effect if we don't set 'delay_create'
1506
trans = get_transport('.')
1507
self.assertRaises(NoSuchFile, KnitVersionedFile, 'dir/test',
1508
trans, access_mode='w', factory=None,
1509
create=True, create_parent_dir=True)
1510
# Nothing should have changed yet
1511
knit = KnitVersionedFile('dir/test', trans, access_mode='w',
1512
factory=None, create=True,
1513
create_parent_dir=True,
1515
self.failIfExists('dir/test.knit')
1516
self.failIfExists('dir/test.kndx')
1517
self.failIfExists('dir')
1518
knit.add_lines('revid', [], ['a\n'])
1519
self.failUnlessExists('dir')
1520
self.failUnlessExists('dir/test.knit')
1521
self.assertFileEqual(
1522
"# bzr knit index 8\n"
1524
"revid fulltext 0 84 :",
1527
def test_create_mode_700(self):
1528
trans = get_transport('.')
1529
if not trans._can_roundtrip_unix_modebits():
1530
# Can't roundtrip, so no need to run this test
1532
knit = KnitVersionedFile('dir/test', trans, access_mode='w',
1533
factory=None, create=True,
1534
create_parent_dir=True,
1538
knit.add_lines('revid', [], ['a\n'])
1539
self.assertTransportMode(trans, 'dir', 0700)
1540
self.assertTransportMode(trans, 'dir/test.knit', 0600)
1541
self.assertTransportMode(trans, 'dir/test.kndx', 0600)
1543
def test_create_mode_770(self):
1544
trans = get_transport('.')
1545
if not trans._can_roundtrip_unix_modebits():
1546
# Can't roundtrip, so no need to run this test
1548
knit = KnitVersionedFile('dir/test', trans, access_mode='w',
1549
factory=None, create=True,
1550
create_parent_dir=True,
1554
knit.add_lines('revid', [], ['a\n'])
1555
self.assertTransportMode(trans, 'dir', 0770)
1556
self.assertTransportMode(trans, 'dir/test.knit', 0660)
1557
self.assertTransportMode(trans, 'dir/test.kndx', 0660)
1559
def test_create_mode_777(self):
1560
trans = get_transport('.')
1561
if not trans._can_roundtrip_unix_modebits():
1562
# Can't roundtrip, so no need to run this test
1564
knit = KnitVersionedFile('dir/test', trans, access_mode='w',
1565
factory=None, create=True,
1566
create_parent_dir=True,
1570
knit.add_lines('revid', [], ['a\n'])
1571
self.assertTransportMode(trans, 'dir', 0777)
1572
self.assertTransportMode(trans, 'dir/test.knit', 0666)
1573
self.assertTransportMode(trans, 'dir/test.kndx', 0666)
1575
def test_plan_merge(self):
1576
my_knit = self.make_test_knit(annotate=True)
1577
my_knit.add_lines('text1', [], split_lines(TEXT_1))
1578
my_knit.add_lines('text1a', ['text1'], split_lines(TEXT_1A))
1579
my_knit.add_lines('text1b', ['text1'], split_lines(TEXT_1B))
1580
plan = list(my_knit.plan_merge('text1a', 'text1b'))
1581
for plan_line, expected_line in zip(plan, AB_MERGE):
1582
self.assertEqual(plan_line, expected_line)
1584
def test_get_stream_empty(self):
1585
"""Get a data stream for an empty knit file."""
1586
k1 = self.make_test_knit()
1587
format, data_list, reader_callable = k1.get_data_stream([])
1588
self.assertEqual('knit-plain', format)
1589
self.assertEqual([], data_list)
1590
content = reader_callable(None)
1591
self.assertEqual('', content)
1592
self.assertIsInstance(content, str)
1594
def test_get_stream_one_version(self):
1595
"""Get a data stream for a single record out of a knit containing just
1598
k1 = self.make_test_knit()
1600
('text-a', [], TEXT_1),
1602
expected_data_list = [
1603
# version, options, length, parents
1604
('text-a', ['fulltext'], 122, ()),
1606
for version_id, parents, lines in test_data:
1607
k1.add_lines(version_id, parents, split_lines(lines))
1609
format, data_list, reader_callable = k1.get_data_stream(['text-a'])
1610
self.assertEqual('knit-plain', format)
1611
self.assertEqual(expected_data_list, data_list)
1612
# There's only one record in the knit, so the content should be the
1613
# entire knit data file's contents.
1614
self.assertEqual(k1.transport.get_bytes(k1._data._access._filename),
1615
reader_callable(None))
1617
def test_get_stream_get_one_version_of_many(self):
1618
"""Get a data stream for just one version out of a knit containing many
1621
k1 = self.make_test_knit()
1622
# Insert the same data as test_knit_join, as they seem to cover a range
1623
# of cases (no parents, one parent, multiple parents).
1625
('text-a', [], TEXT_1),
1626
('text-b', ['text-a'], TEXT_1),
1627
('text-c', [], TEXT_1),
1628
('text-d', ['text-c'], TEXT_1),
1629
('text-m', ['text-b', 'text-d'], TEXT_1),
1631
expected_data_list = [
1632
# version, options, length, parents
1633
('text-m', ['line-delta'], 84, ('text-b', 'text-d')),
1635
for version_id, parents, lines in test_data:
1636
k1.add_lines(version_id, parents, split_lines(lines))
1638
format, data_list, reader_callable = k1.get_data_stream(['text-m'])
1639
self.assertEqual('knit-plain', format)
1640
self.assertEqual(expected_data_list, data_list)
1641
self.assertRecordContentEqual(k1, 'text-m', reader_callable(None))
1643
def test_get_data_stream_unordered_index(self):
1644
"""Get a data stream when the knit index reports versions out of order.
1646
https://bugs.launchpad.net/bzr/+bug/164637
1648
k1 = self.make_test_knit()
1650
('text-a', [], TEXT_1),
1651
('text-b', ['text-a'], TEXT_1),
1652
('text-c', [], TEXT_1),
1653
('text-d', ['text-c'], TEXT_1),
1654
('text-m', ['text-b', 'text-d'], TEXT_1),
1656
for version_id, parents, lines in test_data:
1657
k1.add_lines(version_id, parents, split_lines(lines))
1658
# monkey-patch versions method to return out of order, as if coming
1659
# from multiple independently indexed packs
1660
original_versions = k1.versions
1661
k1.versions = lambda: reversed(original_versions())
1662
expected_data_list = [
1663
('text-a', ['fulltext'], 122, ()),
1664
('text-b', ['line-delta'], 84, ('text-a',))]
1665
# now check the fulltext is first and the delta second
1666
format, data_list, _ = k1.get_data_stream(['text-a', 'text-b'])
1667
self.assertEqual('knit-plain', format)
1668
self.assertEqual(expected_data_list, data_list)
1669
# and that's true if we ask for them in the opposite order too
1670
format, data_list, _ = k1.get_data_stream(['text-b', 'text-a'])
1671
self.assertEqual(expected_data_list, data_list)
1672
# also try requesting more versions
1673
format, data_list, _ = k1.get_data_stream([
1674
'text-m', 'text-b', 'text-a'])
1676
('text-a', ['fulltext'], 122, ()),
1677
('text-b', ['line-delta'], 84, ('text-a',)),
1678
('text-m', ['line-delta'], 84, ('text-b', 'text-d')),
1681
def test_get_stream_ghost_parent(self):
1682
"""Get a data stream for a version with a ghost parent."""
1683
k1 = self.make_test_knit()
1685
k1.add_lines('text-a', [], split_lines(TEXT_1))
1686
k1.add_lines_with_ghosts('text-b', ['text-a', 'text-ghost'],
1687
split_lines(TEXT_1))
1689
expected_data_list = [
1690
# version, options, length, parents
1691
('text-b', ['line-delta'], 84, ('text-a', 'text-ghost')),
1694
format, data_list, reader_callable = k1.get_data_stream(['text-b'])
1695
self.assertEqual('knit-plain', format)
1696
self.assertEqual(expected_data_list, data_list)
1697
self.assertRecordContentEqual(k1, 'text-b', reader_callable(None))
1699
def test_get_stream_get_multiple_records(self):
1700
"""Get a stream for multiple records of a knit."""
1701
k1 = self.make_test_knit()
1702
# Insert the same data as test_knit_join, as they seem to cover a range
1703
# of cases (no parents, one parent, multiple parents).
1705
('text-a', [], TEXT_1),
1706
('text-b', ['text-a'], TEXT_1),
1707
('text-c', [], TEXT_1),
1708
('text-d', ['text-c'], TEXT_1),
1709
('text-m', ['text-b', 'text-d'], TEXT_1),
1711
for version_id, parents, lines in test_data:
1712
k1.add_lines(version_id, parents, split_lines(lines))
1714
# This test is actually a bit strict as the order in which they're
1715
# returned is not defined. This matches the current (deterministic)
1717
expected_data_list = [
1718
# version, options, length, parents
1719
('text-d', ['line-delta'], 84, ('text-c',)),
1720
('text-b', ['line-delta'], 84, ('text-a',)),
1722
# Note that even though we request the revision IDs in a particular
1723
# order, the data stream may return them in any order it likes. In this
1724
# case, they'll be in the order they were inserted into the knit.
1725
format, data_list, reader_callable = k1.get_data_stream(
1726
['text-d', 'text-b'])
1727
self.assertEqual('knit-plain', format)
1728
self.assertEqual(expected_data_list, data_list)
1729
# must match order they're returned
1730
self.assertRecordContentEqual(k1, 'text-d', reader_callable(84))
1731
self.assertRecordContentEqual(k1, 'text-b', reader_callable(84))
1732
self.assertEqual('', reader_callable(None),
1733
"There should be no more bytes left to read.")
1735
def test_get_stream_all(self):
1736
"""Get a data stream for all the records in a knit.
1738
This exercises fulltext records, line-delta records, records with
1739
various numbers of parents, and reading multiple records out of the
1740
callable. These cases ought to all be exercised individually by the
1741
other test_get_stream_* tests; this test is basically just paranoia.
1743
k1 = self.make_test_knit()
1744
# Insert the same data as test_knit_join, as they seem to cover a range
1745
# of cases (no parents, one parent, multiple parents).
1747
('text-a', [], TEXT_1),
1748
('text-b', ['text-a'], TEXT_1),
1749
('text-c', [], TEXT_1),
1750
('text-d', ['text-c'], TEXT_1),
1751
('text-m', ['text-b', 'text-d'], TEXT_1),
1753
for version_id, parents, lines in test_data:
1754
k1.add_lines(version_id, parents, split_lines(lines))
1756
# This test is actually a bit strict as the order in which they're
1757
# returned is not defined. This matches the current (deterministic)
1759
expected_data_list = [
1760
# version, options, length, parents
1761
('text-a', ['fulltext'], 122, ()),
1762
('text-b', ['line-delta'], 84, ('text-a',)),
1763
('text-m', ['line-delta'], 84, ('text-b', 'text-d')),
1764
('text-c', ['fulltext'], 121, ()),
1765
('text-d', ['line-delta'], 84, ('text-c',)),
1767
format, data_list, reader_callable = k1.get_data_stream(
1768
['text-a', 'text-b', 'text-c', 'text-d', 'text-m'])
1769
self.assertEqual('knit-plain', format)
1770
self.assertEqual(expected_data_list, data_list)
1771
for version_id, options, length, parents in expected_data_list:
1772
bytes = reader_callable(length)
1773
self.assertRecordContentEqual(k1, version_id, bytes)
1775
def assertKnitFilesEqual(self, knit1, knit2):
1776
"""Assert that the contents of the index and data files of two knits are
1780
knit1.transport.get_bytes(knit1._data._access._filename),
1781
knit2.transport.get_bytes(knit2._data._access._filename))
1783
knit1.transport.get_bytes(knit1._index._filename),
1784
knit2.transport.get_bytes(knit2._index._filename))
1786
def assertKnitValuesEqual(self, left, right):
1787
"""Assert that the texts, annotations and graph of left and right are
1790
self.assertEqual(set(left.versions()), set(right.versions()))
1791
for version in left.versions():
1792
self.assertEqual(left.get_parents_with_ghosts(version),
1793
right.get_parents_with_ghosts(version))
1794
self.assertEqual(left.get_lines(version),
1795
right.get_lines(version))
1796
self.assertEqual(left.annotate(version),
1797
right.annotate(version))
1799
def test_insert_data_stream_empty(self):
1800
"""Inserting a data stream with no records should not put any data into
1803
k1 = self.make_test_knit()
1804
k1.insert_data_stream(
1805
(k1.get_format_signature(), [], lambda ignored: ''))
1806
self.assertEqual('', k1.transport.get_bytes(k1._data._access._filename),
1807
"The .knit should be completely empty.")
1808
self.assertEqual(k1._index.HEADER,
1809
k1.transport.get_bytes(k1._index._filename),
1810
"The .kndx should have nothing apart from the header.")
1812
def test_insert_data_stream_one_record(self):
1813
"""Inserting a data stream with one record from a knit with one record
1814
results in byte-identical files.
1816
source = self.make_test_knit(name='source')
1817
source.add_lines('text-a', [], split_lines(TEXT_1))
1818
data_stream = source.get_data_stream(['text-a'])
1819
target = self.make_test_knit(name='target')
1820
target.insert_data_stream(data_stream)
1821
self.assertKnitFilesEqual(source, target)
1823
def test_insert_data_stream_annotated_unannotated(self):
1824
"""Inserting an annotated datastream to an unannotated knit works."""
1825
# case one - full texts.
1826
source = self.make_test_knit(name='source', annotate=True)
1827
target = self.make_test_knit(name='target', annotate=False)
1828
source.add_lines('text-a', [], split_lines(TEXT_1))
1829
target.insert_data_stream(source.get_data_stream(['text-a']))
1830
self.assertKnitValuesEqual(source, target)
1831
# case two - deltas.
1832
source.add_lines('text-b', ['text-a'], split_lines(TEXT_2))
1833
target.insert_data_stream(source.get_data_stream(['text-b']))
1834
self.assertKnitValuesEqual(source, target)
1836
def test_insert_data_stream_unannotated_annotated(self):
1837
"""Inserting an unannotated datastream to an annotated knit works."""
1838
# case one - full texts.
1839
source = self.make_test_knit(name='source', annotate=False)
1840
target = self.make_test_knit(name='target', annotate=True)
1841
source.add_lines('text-a', [], split_lines(TEXT_1))
1842
target.insert_data_stream(source.get_data_stream(['text-a']))
1843
self.assertKnitValuesEqual(source, target)
1844
# case two - deltas.
1845
source.add_lines('text-b', ['text-a'], split_lines(TEXT_2))
1846
target.insert_data_stream(source.get_data_stream(['text-b']))
1847
self.assertKnitValuesEqual(source, target)
1849
def test_insert_data_stream_records_already_present(self):
1850
"""Insert a data stream where some records are alreday present in the
1851
target, and some not. Only the new records are inserted.
1853
source = self.make_test_knit(name='source')
1854
target = self.make_test_knit(name='target')
1855
# Insert 'text-a' into both source and target
1856
source.add_lines('text-a', [], split_lines(TEXT_1))
1857
target.insert_data_stream(source.get_data_stream(['text-a']))
1858
# Insert 'text-b' into just the source.
1859
source.add_lines('text-b', ['text-a'], split_lines(TEXT_1))
1860
# Get a data stream of both text-a and text-b, and insert it.
1861
data_stream = source.get_data_stream(['text-a', 'text-b'])
1862
target.insert_data_stream(data_stream)
1863
# The source and target will now be identical. This means the text-a
1864
# record was not added a second time.
1865
self.assertKnitFilesEqual(source, target)
1867
def test_insert_data_stream_multiple_records(self):
1868
"""Inserting a data stream of all records from a knit with multiple
1869
records results in byte-identical files.
1871
source = self.make_test_knit(name='source')
1872
source.add_lines('text-a', [], split_lines(TEXT_1))
1873
source.add_lines('text-b', ['text-a'], split_lines(TEXT_1))
1874
source.add_lines('text-c', [], split_lines(TEXT_1))
1875
data_stream = source.get_data_stream(['text-a', 'text-b', 'text-c'])
1877
target = self.make_test_knit(name='target')
1878
target.insert_data_stream(data_stream)
1880
self.assertKnitFilesEqual(source, target)
1882
def test_insert_data_stream_ghost_parent(self):
1883
"""Insert a data stream with a record that has a ghost parent."""
1884
# Make a knit with a record, text-a, that has a ghost parent.
1885
source = self.make_test_knit(name='source')
1886
source.add_lines_with_ghosts('text-a', ['text-ghost'],
1887
split_lines(TEXT_1))
1888
data_stream = source.get_data_stream(['text-a'])
1890
target = self.make_test_knit(name='target')
1891
target.insert_data_stream(data_stream)
1893
self.assertKnitFilesEqual(source, target)
1895
# The target knit object is in a consistent state, i.e. the record we
1896
# just added is immediately visible.
1897
self.assertTrue(target.has_version('text-a'))
1898
self.assertTrue(target.has_ghost('text-ghost'))
1899
self.assertEqual(split_lines(TEXT_1), target.get_lines('text-a'))
1901
def test_insert_data_stream_inconsistent_version_lines(self):
1902
"""Inserting a data stream which has different content for a version_id
1903
than already exists in the knit will raise KnitCorrupt.
1905
source = self.make_test_knit(name='source')
1906
target = self.make_test_knit(name='target')
1907
# Insert a different 'text-a' into both source and target
1908
source.add_lines('text-a', [], split_lines(TEXT_1))
1909
target.add_lines('text-a', [], split_lines(TEXT_2))
1910
# Insert a data stream with conflicting content into the target
1911
data_stream = source.get_data_stream(['text-a'])
1913
errors.KnitCorrupt, target.insert_data_stream, data_stream)
1915
def test_insert_data_stream_inconsistent_version_parents(self):
1916
"""Inserting a data stream which has different parents for a version_id
1917
than already exists in the knit will raise KnitCorrupt.
1919
source = self.make_test_knit(name='source')
1920
target = self.make_test_knit(name='target')
1921
# Insert a different 'text-a' into both source and target. They differ
1922
# only by the parents list, the content is the same.
1923
source.add_lines_with_ghosts('text-a', [], split_lines(TEXT_1))
1924
target.add_lines_with_ghosts('text-a', ['a-ghost'], split_lines(TEXT_1))
1925
# Insert a data stream with conflicting content into the target
1926
data_stream = source.get_data_stream(['text-a'])
1928
errors.KnitCorrupt, target.insert_data_stream, data_stream)
1930
def test_insert_data_stream_unknown_format(self):
1931
"""A data stream in a different format to the target knit cannot be
1934
It will raise KnitDataStreamUnknown because the fallback code will fail
1935
to make a knit. In future we may need KnitDataStreamIncompatible again,
1936
for more exotic cases.
1938
data_stream = ('fake-format-signature', [], lambda _: '')
1939
target = self.make_test_knit(name='target')
1941
errors.KnitDataStreamUnknown,
1942
target.insert_data_stream, data_stream)
1944
# * test that a stream of "already present version, then new version"
1945
# inserts correctly.
1948
def assertMadeStreamKnit(self, source_knit, versions, target_knit):
1949
"""Assert that a knit made from a stream is as expected."""
1950
a_stream = source_knit.get_data_stream(versions)
1951
expected_data = a_stream[2](None)
1952
a_stream = source_knit.get_data_stream(versions)
1953
a_knit = target_knit._knit_from_datastream(a_stream)
1954
self.assertEqual(source_knit.factory.__class__,
1955
a_knit.factory.__class__)
1956
self.assertIsInstance(a_knit._data._access, _StreamAccess)
1957
self.assertIsInstance(a_knit._index, _StreamIndex)
1958
self.assertEqual(a_knit._index.data_list, a_stream[1])
1959
self.assertEqual(a_knit._data._access.data, expected_data)
1960
self.assertEqual(a_knit.filename, target_knit.filename)
1961
self.assertEqual(a_knit.transport, target_knit.transport)
1962
self.assertEqual(a_knit._index, a_knit._data._access.stream_index)
1963
self.assertEqual(target_knit, a_knit._data._access.backing_knit)
1964
self.assertIsInstance(a_knit._data._access.orig_factory,
1965
source_knit.factory.__class__)
1967
def test__knit_from_data_stream_empty(self):
1968
"""Create a knit object from a datastream."""
1969
annotated = self.make_test_knit(name='source', annotate=True)
1970
plain = self.make_test_knit(name='target', annotate=False)
1971
# case 1: annotated source
1972
self.assertMadeStreamKnit(annotated, [], annotated)
1973
self.assertMadeStreamKnit(annotated, [], plain)
1974
# case 2: plain source
1975
self.assertMadeStreamKnit(plain, [], annotated)
1976
self.assertMadeStreamKnit(plain, [], plain)
1978
def test__knit_from_data_stream_unknown_format(self):
1979
annotated = self.make_test_knit(name='source', annotate=True)
1980
self.assertRaises(errors.KnitDataStreamUnknown,
1981
annotated._knit_from_datastream, ("unknown", None, None))
1993
Banana cup cake recipe
1999
- self-raising flour
2003
Banana cup cake recipe
2005
- bananas (do not use plantains!!!)
2012
Banana cup cake recipe
2015
- self-raising flour
2028
AB_MERGE_TEXT="""unchanged|Banana cup cake recipe
2033
new-b|- bananas (do not use plantains!!!)
2034
unchanged|- broken tea cups
2035
new-a|- self-raising flour
2038
AB_MERGE=[tuple(l.split('|')) for l in AB_MERGE_TEXT.splitlines(True)]
2041
def line_delta(from_lines, to_lines):
2042
"""Generate line-based delta from one text to another"""
2043
s = difflib.SequenceMatcher(None, from_lines, to_lines)
2044
for op in s.get_opcodes():
2045
if op[0] == 'equal':
2047
yield '%d,%d,%d\n' % (op[1], op[2], op[4]-op[3])
2048
for i in range(op[3], op[4]):
2052
def apply_line_delta(basis_lines, delta_lines):
2053
"""Apply a line-based perfect diff
2055
basis_lines -- text to apply the patch to
2056
delta_lines -- diff instructions and content
2058
out = basis_lines[:]
2061
while i < len(delta_lines):
2063
a, b, c = map(long, l.split(','))
2065
out[offset+a:offset+b] = delta_lines[i:i+c]
2067
offset = offset + (b - a) + c
2071
class TestWeaveToKnit(KnitTests):
2073
def test_weave_to_knit_matches(self):
2074
# check that the WeaveToKnit is_compatible function
2075
# registers True for a Weave to a Knit.
2077
k = self.make_test_knit()
2078
self.failUnless(WeaveToKnit.is_compatible(w, k))
2079
self.failIf(WeaveToKnit.is_compatible(k, w))
2080
self.failIf(WeaveToKnit.is_compatible(w, w))
2081
self.failIf(WeaveToKnit.is_compatible(k, k))
2084
class TestKnitCaching(KnitTests):
2086
def create_knit(self):
2087
k = self.make_test_knit(True)
2088
k.add_lines('text-1', [], split_lines(TEXT_1))
2089
k.add_lines('text-2', [], split_lines(TEXT_2))
2092
def test_no_caching(self):
2093
k = self.create_knit()
2094
# Nothing should be cached without setting 'enable_cache'
2095
self.assertEqual({}, k._data._cache)
2097
def test_cache_data_read_raw(self):
2098
k = self.create_knit()
2100
# Now cache and read
2103
def read_one_raw(version):
2104
pos_map = k._get_components_positions([version])
2105
method, index_memo, next = pos_map[version]
2106
lst = list(k._data.read_records_iter_raw([(version, index_memo)]))
2107
self.assertEqual(1, len(lst))
2110
val = read_one_raw('text-1')
2111
self.assertEqual({'text-1':val[1]}, k._data._cache)
2114
# After clear, new reads are not cached
2115
self.assertEqual({}, k._data._cache)
2117
val2 = read_one_raw('text-1')
2118
self.assertEqual(val, val2)
2119
self.assertEqual({}, k._data._cache)
2121
def test_cache_data_read(self):
2122
k = self.create_knit()
2124
def read_one(version):
2125
pos_map = k._get_components_positions([version])
2126
method, index_memo, next = pos_map[version]
2127
lst = list(k._data.read_records_iter([(version, index_memo)]))
2128
self.assertEqual(1, len(lst))
2131
# Now cache and read
2134
val = read_one('text-2')
2135
self.assertEqual(['text-2'], k._data._cache.keys())
2136
self.assertEqual('text-2', val[0])
2137
content, digest = k._data._parse_record('text-2',
2138
k._data._cache['text-2'])
2139
self.assertEqual(content, val[1])
2140
self.assertEqual(digest, val[2])
2143
self.assertEqual({}, k._data._cache)
2145
val2 = read_one('text-2')
2146
self.assertEqual(val, val2)
2147
self.assertEqual({}, k._data._cache)
2149
def test_cache_read(self):
2150
k = self.create_knit()
2153
text = k.get_text('text-1')
2154
self.assertEqual(TEXT_1, text)
2155
self.assertEqual(['text-1'], k._data._cache.keys())
2158
self.assertEqual({}, k._data._cache)
2160
text = k.get_text('text-1')
2161
self.assertEqual(TEXT_1, text)
2162
self.assertEqual({}, k._data._cache)
2165
class TestKnitIndex(KnitTests):
2167
def test_add_versions_dictionary_compresses(self):
2168
"""Adding versions to the index should update the lookup dict"""
2169
knit = self.make_test_knit()
2171
idx.add_version('a-1', ['fulltext'], (None, 0, 0), [])
2172
self.check_file_contents('test.kndx',
2173
'# bzr knit index 8\n'
2175
'a-1 fulltext 0 0 :'
2177
idx.add_versions([('a-2', ['fulltext'], (None, 0, 0), ['a-1']),
2178
('a-3', ['fulltext'], (None, 0, 0), ['a-2']),
2180
self.check_file_contents('test.kndx',
2181
'# bzr knit index 8\n'
2183
'a-1 fulltext 0 0 :\n'
2184
'a-2 fulltext 0 0 0 :\n'
2185
'a-3 fulltext 0 0 1 :'
2187
self.assertEqual(['a-1', 'a-2', 'a-3'], idx._history)
2188
self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, (), 0),
2189
'a-2':('a-2', ['fulltext'], 0, 0, ('a-1',), 1),
2190
'a-3':('a-3', ['fulltext'], 0, 0, ('a-2',), 2),
2193
def test_add_versions_fails_clean(self):
2194
"""If add_versions fails in the middle, it restores a pristine state.
2196
Any modifications that are made to the index are reset if all versions
2199
# This cheats a little bit by passing in a generator which will
2200
# raise an exception before the processing finishes
2201
# Other possibilities would be to have an version with the wrong number
2202
# of entries, or to make the backing transport unable to write any
2205
knit = self.make_test_knit()
2207
idx.add_version('a-1', ['fulltext'], (None, 0, 0), [])
2209
class StopEarly(Exception):
2212
def generate_failure():
2213
"""Add some entries and then raise an exception"""
2214
yield ('a-2', ['fulltext'], (None, 0, 0), ('a-1',))
2215
yield ('a-3', ['fulltext'], (None, 0, 0), ('a-2',))
2218
# Assert the pre-condition
2219
self.assertEqual(['a-1'], idx._history)
2220
self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, (), 0)}, idx._cache)
2222
self.assertRaises(StopEarly, idx.add_versions, generate_failure())
2224
# And it shouldn't be modified
2225
self.assertEqual(['a-1'], idx._history)
2226
self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, (), 0)}, idx._cache)
2228
def test_knit_index_ignores_empty_files(self):
2229
# There was a race condition in older bzr, where a ^C at the right time
2230
# could leave an empty .kndx file, which bzr would later claim was a
2231
# corrupted file since the header was not present. In reality, the file
2232
# just wasn't created, so it should be ignored.
2233
t = get_transport('.')
2234
t.put_bytes('test.kndx', '')
2236
knit = self.make_test_knit()
2238
def test_knit_index_checks_header(self):
2239
t = get_transport('.')
2240
t.put_bytes('test.kndx', '# not really a knit header\n\n')
2242
self.assertRaises(KnitHeaderError, self.make_test_knit)
2245
class TestGraphIndexKnit(KnitTests):
2246
"""Tests for knits using a GraphIndex rather than a KnitIndex."""
2248
def make_g_index(self, name, ref_lists=0, nodes=[]):
2249
builder = GraphIndexBuilder(ref_lists)
2250
for node, references, value in nodes:
2251
builder.add_node(node, references, value)
2252
stream = builder.finish()
2253
trans = self.get_transport()
2254
size = trans.put_file(name, stream)
2255
return GraphIndex(trans, name, size)
2257
def two_graph_index(self, deltas=False, catch_adds=False):
2258
"""Build a two-graph index.
2260
:param deltas: If true, use underlying indices with two node-ref
2261
lists and 'parent' set to a delta-compressed against tail.
2263
# build a complex graph across several indices.
2265
# delta compression inn the index
2266
index1 = self.make_g_index('1', 2, [
2267
(('tip', ), 'N0 100', ([('parent', )], [], )),
2268
(('tail', ), '', ([], []))])
2269
index2 = self.make_g_index('2', 2, [
2270
(('parent', ), ' 100 78', ([('tail', ), ('ghost', )], [('tail', )])),
2271
(('separate', ), '', ([], []))])
2273
# just blob location and graph in the index.
2274
index1 = self.make_g_index('1', 1, [
2275
(('tip', ), 'N0 100', ([('parent', )], )),
2276
(('tail', ), '', ([], ))])
2277
index2 = self.make_g_index('2', 1, [
2278
(('parent', ), ' 100 78', ([('tail', ), ('ghost', )], )),
2279
(('separate', ), '', ([], ))])
2280
combined_index = CombinedGraphIndex([index1, index2])
2282
self.combined_index = combined_index
2283
self.caught_entries = []
2284
add_callback = self.catch_add
2287
return KnitGraphIndex(combined_index, deltas=deltas,
2288
add_callback=add_callback)
2290
def test_get_graph(self):
2291
index = self.two_graph_index()
2292
self.assertEqual(set([
2293
('tip', ('parent', )),
2295
('parent', ('tail', 'ghost')),
2297
]), set(index.get_graph()))
2299
def test_get_ancestry(self):
2300
# get_ancestry is defined as eliding ghosts, not erroring.
2301
index = self.two_graph_index()
2302
self.assertEqual([], index.get_ancestry([]))
2303
self.assertEqual(['separate'], index.get_ancestry(['separate']))
2304
self.assertEqual(['tail'], index.get_ancestry(['tail']))
2305
self.assertEqual(['tail', 'parent'], index.get_ancestry(['parent']))
2306
self.assertEqual(['tail', 'parent', 'tip'], index.get_ancestry(['tip']))
2307
self.assertTrue(index.get_ancestry(['tip', 'separate']) in
2308
(['tail', 'parent', 'tip', 'separate'],
2309
['separate', 'tail', 'parent', 'tip'],
2311
# and without topo_sort
2312
self.assertEqual(set(['separate']),
2313
set(index.get_ancestry(['separate'], topo_sorted=False)))
2314
self.assertEqual(set(['tail']),
2315
set(index.get_ancestry(['tail'], topo_sorted=False)))
2316
self.assertEqual(set(['tail', 'parent']),
2317
set(index.get_ancestry(['parent'], topo_sorted=False)))
2318
self.assertEqual(set(['tail', 'parent', 'tip']),
2319
set(index.get_ancestry(['tip'], topo_sorted=False)))
2320
self.assertEqual(set(['separate', 'tail', 'parent', 'tip']),
2321
set(index.get_ancestry(['tip', 'separate'])))
2322
# asking for a ghost makes it go boom.
2323
self.assertRaises(errors.RevisionNotPresent, index.get_ancestry, ['ghost'])
2325
def test_get_ancestry_with_ghosts(self):
2326
index = self.two_graph_index()
2327
self.assertEqual([], index.get_ancestry_with_ghosts([]))
2328
self.assertEqual(['separate'], index.get_ancestry_with_ghosts(['separate']))
2329
self.assertEqual(['tail'], index.get_ancestry_with_ghosts(['tail']))
2330
self.assertTrue(index.get_ancestry_with_ghosts(['parent']) in
2331
(['tail', 'ghost', 'parent'],
2332
['ghost', 'tail', 'parent'],
2334
self.assertTrue(index.get_ancestry_with_ghosts(['tip']) in
2335
(['tail', 'ghost', 'parent', 'tip'],
2336
['ghost', 'tail', 'parent', 'tip'],
2338
self.assertTrue(index.get_ancestry_with_ghosts(['tip', 'separate']) in
2339
(['tail', 'ghost', 'parent', 'tip', 'separate'],
2340
['ghost', 'tail', 'parent', 'tip', 'separate'],
2341
['separate', 'tail', 'ghost', 'parent', 'tip'],
2342
['separate', 'ghost', 'tail', 'parent', 'tip'],
2344
# asking for a ghost makes it go boom.
2345
self.assertRaises(errors.RevisionNotPresent, index.get_ancestry_with_ghosts, ['ghost'])
2347
def test_num_versions(self):
2348
index = self.two_graph_index()
2349
self.assertEqual(4, index.num_versions())
2351
def test_get_versions(self):
2352
index = self.two_graph_index()
2353
self.assertEqual(set(['tail', 'tip', 'parent', 'separate']),
2354
set(index.get_versions()))
2356
def test_has_version(self):
2357
index = self.two_graph_index()
2358
self.assertTrue(index.has_version('tail'))
2359
self.assertFalse(index.has_version('ghost'))
2361
def test_get_position(self):
2362
index = self.two_graph_index()
2363
self.assertEqual((index._graph_index._indices[0], 0, 100), index.get_position('tip'))
2364
self.assertEqual((index._graph_index._indices[1], 100, 78), index.get_position('parent'))
2366
def test_get_method_deltas(self):
2367
index = self.two_graph_index(deltas=True)
2368
self.assertEqual('fulltext', index.get_method('tip'))
2369
self.assertEqual('line-delta', index.get_method('parent'))
2371
def test_get_method_no_deltas(self):
2372
# check that the parent-history lookup is ignored with deltas=False.
2373
index = self.two_graph_index(deltas=False)
2374
self.assertEqual('fulltext', index.get_method('tip'))
2375
self.assertEqual('fulltext', index.get_method('parent'))
2377
def test_get_options_deltas(self):
2378
index = self.two_graph_index(deltas=True)
2379
self.assertEqual(['fulltext', 'no-eol'], index.get_options('tip'))
2380
self.assertEqual(['line-delta'], index.get_options('parent'))
2382
def test_get_options_no_deltas(self):
2383
# check that the parent-history lookup is ignored with deltas=False.
2384
index = self.two_graph_index(deltas=False)
2385
self.assertEqual(['fulltext', 'no-eol'], index.get_options('tip'))
2386
self.assertEqual(['fulltext'], index.get_options('parent'))
2388
def test_get_parents_with_ghosts(self):
2389
index = self.two_graph_index()
2390
self.assertEqual(('tail', 'ghost'), index.get_parents_with_ghosts('parent'))
2391
# and errors on ghosts.
2392
self.assertRaises(errors.RevisionNotPresent,
2393
index.get_parents_with_ghosts, 'ghost')
2395
def test_check_versions_present(self):
2396
# ghosts should not be considered present
2397
index = self.two_graph_index()
2398
self.assertRaises(RevisionNotPresent, index.check_versions_present,
2400
self.assertRaises(RevisionNotPresent, index.check_versions_present,
2402
index.check_versions_present(['tail', 'separate'])
2404
def catch_add(self, entries):
2405
self.caught_entries.append(entries)
2407
def test_add_no_callback_errors(self):
2408
index = self.two_graph_index()
2409
self.assertRaises(errors.ReadOnlyError, index.add_version,
2410
'new', 'fulltext,no-eol', (None, 50, 60), ['separate'])
2412
def test_add_version_smoke(self):
2413
index = self.two_graph_index(catch_adds=True)
2414
index.add_version('new', 'fulltext,no-eol', (None, 50, 60), ['separate'])
2415
self.assertEqual([[(('new', ), 'N50 60', ((('separate',),),))]],
2416
self.caught_entries)
2418
def test_add_version_delta_not_delta_index(self):
2419
index = self.two_graph_index(catch_adds=True)
2420
self.assertRaises(errors.KnitCorrupt, index.add_version,
2421
'new', 'no-eol,line-delta', (None, 0, 100), ['parent'])
2422
self.assertEqual([], self.caught_entries)
2424
def test_add_version_same_dup(self):
2425
index = self.two_graph_index(catch_adds=True)
2426
# options can be spelt two different ways
2427
index.add_version('tip', 'fulltext,no-eol', (None, 0, 100), ['parent'])
2428
index.add_version('tip', 'no-eol,fulltext', (None, 0, 100), ['parent'])
2429
# but neither should have added data.
2430
self.assertEqual([[], []], self.caught_entries)
2432
def test_add_version_different_dup(self):
2433
index = self.two_graph_index(deltas=True, catch_adds=True)
2435
self.assertRaises(errors.KnitCorrupt, index.add_version,
2436
'tip', 'no-eol,line-delta', (None, 0, 100), ['parent'])
2437
self.assertRaises(errors.KnitCorrupt, index.add_version,
2438
'tip', 'line-delta,no-eol', (None, 0, 100), ['parent'])
2439
self.assertRaises(errors.KnitCorrupt, index.add_version,
2440
'tip', 'fulltext', (None, 0, 100), ['parent'])
2442
self.assertRaises(errors.KnitCorrupt, index.add_version,
2443
'tip', 'fulltext,no-eol', (None, 50, 100), ['parent'])
2444
self.assertRaises(errors.KnitCorrupt, index.add_version,
2445
'tip', 'fulltext,no-eol', (None, 0, 1000), ['parent'])
2447
self.assertRaises(errors.KnitCorrupt, index.add_version,
2448
'tip', 'fulltext,no-eol', (None, 0, 100), [])
2449
self.assertEqual([], self.caught_entries)
2451
def test_add_versions_nodeltas(self):
2452
index = self.two_graph_index(catch_adds=True)
2453
index.add_versions([
2454
('new', 'fulltext,no-eol', (None, 50, 60), ['separate']),
2455
('new2', 'fulltext', (None, 0, 6), ['new']),
2457
self.assertEqual([(('new', ), 'N50 60', ((('separate',),),)),
2458
(('new2', ), ' 0 6', ((('new',),),))],
2459
sorted(self.caught_entries[0]))
2460
self.assertEqual(1, len(self.caught_entries))
2462
def test_add_versions_deltas(self):
2463
index = self.two_graph_index(deltas=True, catch_adds=True)
2464
index.add_versions([
2465
('new', 'fulltext,no-eol', (None, 50, 60), ['separate']),
2466
('new2', 'line-delta', (None, 0, 6), ['new']),
2468
self.assertEqual([(('new', ), 'N50 60', ((('separate',),), ())),
2469
(('new2', ), ' 0 6', ((('new',),), (('new',),), ))],
2470
sorted(self.caught_entries[0]))
2471
self.assertEqual(1, len(self.caught_entries))
2473
def test_add_versions_delta_not_delta_index(self):
2474
index = self.two_graph_index(catch_adds=True)
2475
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2476
[('new', 'no-eol,line-delta', (None, 0, 100), ['parent'])])
2477
self.assertEqual([], self.caught_entries)
2479
def test_add_versions_random_id_accepted(self):
2480
index = self.two_graph_index(catch_adds=True)
2481
index.add_versions([], random_id=True)
2483
def test_add_versions_same_dup(self):
2484
index = self.two_graph_index(catch_adds=True)
2485
# options can be spelt two different ways
2486
index.add_versions([('tip', 'fulltext,no-eol', (None, 0, 100), ['parent'])])
2487
index.add_versions([('tip', 'no-eol,fulltext', (None, 0, 100), ['parent'])])
2488
# but neither should have added data.
2489
self.assertEqual([[], []], self.caught_entries)
2491
def test_add_versions_different_dup(self):
2492
index = self.two_graph_index(deltas=True, catch_adds=True)
2494
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2495
[('tip', 'no-eol,line-delta', (None, 0, 100), ['parent'])])
2496
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2497
[('tip', 'line-delta,no-eol', (None, 0, 100), ['parent'])])
2498
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2499
[('tip', 'fulltext', (None, 0, 100), ['parent'])])
2501
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2502
[('tip', 'fulltext,no-eol', (None, 50, 100), ['parent'])])
2503
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2504
[('tip', 'fulltext,no-eol', (None, 0, 1000), ['parent'])])
2506
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2507
[('tip', 'fulltext,no-eol', (None, 0, 100), [])])
2508
# change options in the second record
2509
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2510
[('tip', 'fulltext,no-eol', (None, 0, 100), ['parent']),
2511
('tip', 'no-eol,line-delta', (None, 0, 100), ['parent'])])
2512
self.assertEqual([], self.caught_entries)
2514
def test_iter_parents(self):
2515
index1 = self.make_g_index('1', 1, [
2517
(('r0', ), 'N0 100', ([], )),
2519
(('r1', ), '', ([('r0', )], ))])
2520
index2 = self.make_g_index('2', 1, [
2522
(('r2', ), 'N0 100', ([('r1', ), ('r0', )], )),
2524
combined_index = CombinedGraphIndex([index1, index2])
2525
index = KnitGraphIndex(combined_index)
2527
# cases: each sample data individually:
2528
self.assertEqual(set([('r0', ())]),
2529
set(index.iter_parents(['r0'])))
2530
self.assertEqual(set([('r1', ('r0', ))]),
2531
set(index.iter_parents(['r1'])))
2532
self.assertEqual(set([('r2', ('r1', 'r0'))]),
2533
set(index.iter_parents(['r2'])))
2534
# no nodes returned for a missing node
2535
self.assertEqual(set(),
2536
set(index.iter_parents(['missing'])))
2537
# 1 node returned with missing nodes skipped
2538
self.assertEqual(set([('r1', ('r0', ))]),
2539
set(index.iter_parents(['ghost1', 'r1', 'ghost'])))
2541
self.assertEqual(set([('r0', ()), ('r1', ('r0', ))]),
2542
set(index.iter_parents(['r0', 'r1'])))
2543
# 2 nodes returned, missing skipped
2544
self.assertEqual(set([('r0', ()), ('r1', ('r0', ))]),
2545
set(index.iter_parents(['a', 'r0', 'b', 'r1', 'c'])))
2548
class TestNoParentsGraphIndexKnit(KnitTests):
2549
"""Tests for knits using KnitGraphIndex with no parents."""
2551
def make_g_index(self, name, ref_lists=0, nodes=[]):
2552
builder = GraphIndexBuilder(ref_lists)
2553
for node, references in nodes:
2554
builder.add_node(node, references)
2555
stream = builder.finish()
2556
trans = self.get_transport()
2557
size = trans.put_file(name, stream)
2558
return GraphIndex(trans, name, size)
2560
def test_parents_deltas_incompatible(self):
2561
index = CombinedGraphIndex([])
2562
self.assertRaises(errors.KnitError, KnitGraphIndex, index,
2563
deltas=True, parents=False)
2565
def two_graph_index(self, catch_adds=False):
2566
"""Build a two-graph index.
2568
:param deltas: If true, use underlying indices with two node-ref
2569
lists and 'parent' set to a delta-compressed against tail.
2571
# put several versions in the index.
2572
index1 = self.make_g_index('1', 0, [
2573
(('tip', ), 'N0 100'),
2575
index2 = self.make_g_index('2', 0, [
2576
(('parent', ), ' 100 78'),
2577
(('separate', ), '')])
2578
combined_index = CombinedGraphIndex([index1, index2])
2580
self.combined_index = combined_index
2581
self.caught_entries = []
2582
add_callback = self.catch_add
2585
return KnitGraphIndex(combined_index, parents=False,
2586
add_callback=add_callback)
2588
def test_get_graph(self):
2589
index = self.two_graph_index()
2590
self.assertEqual(set([
2595
]), set(index.get_graph()))
2597
def test_get_ancestry(self):
2598
# with no parents, ancestry is always just the key.
2599
index = self.two_graph_index()
2600
self.assertEqual([], index.get_ancestry([]))
2601
self.assertEqual(['separate'], index.get_ancestry(['separate']))
2602
self.assertEqual(['tail'], index.get_ancestry(['tail']))
2603
self.assertEqual(['parent'], index.get_ancestry(['parent']))
2604
self.assertEqual(['tip'], index.get_ancestry(['tip']))
2605
self.assertTrue(index.get_ancestry(['tip', 'separate']) in
2606
(['tip', 'separate'],
2607
['separate', 'tip'],
2609
# asking for a ghost makes it go boom.
2610
self.assertRaises(errors.RevisionNotPresent, index.get_ancestry, ['ghost'])
2612
def test_get_ancestry_with_ghosts(self):
2613
index = self.two_graph_index()
2614
self.assertEqual([], index.get_ancestry_with_ghosts([]))
2615
self.assertEqual(['separate'], index.get_ancestry_with_ghosts(['separate']))
2616
self.assertEqual(['tail'], index.get_ancestry_with_ghosts(['tail']))
2617
self.assertEqual(['parent'], index.get_ancestry_with_ghosts(['parent']))
2618
self.assertEqual(['tip'], index.get_ancestry_with_ghosts(['tip']))
2619
self.assertTrue(index.get_ancestry_with_ghosts(['tip', 'separate']) in
2620
(['tip', 'separate'],
2621
['separate', 'tip'],
2623
# asking for a ghost makes it go boom.
2624
self.assertRaises(errors.RevisionNotPresent, index.get_ancestry_with_ghosts, ['ghost'])
2626
def test_num_versions(self):
2627
index = self.two_graph_index()
2628
self.assertEqual(4, index.num_versions())
2630
def test_get_versions(self):
2631
index = self.two_graph_index()
2632
self.assertEqual(set(['tail', 'tip', 'parent', 'separate']),
2633
set(index.get_versions()))
2635
def test_has_version(self):
2636
index = self.two_graph_index()
2637
self.assertTrue(index.has_version('tail'))
2638
self.assertFalse(index.has_version('ghost'))
2640
def test_get_position(self):
2641
index = self.two_graph_index()
2642
self.assertEqual((index._graph_index._indices[0], 0, 100), index.get_position('tip'))
2643
self.assertEqual((index._graph_index._indices[1], 100, 78), index.get_position('parent'))
2645
def test_get_method(self):
2646
index = self.two_graph_index()
2647
self.assertEqual('fulltext', index.get_method('tip'))
2648
self.assertEqual(['fulltext'], index.get_options('parent'))
2650
def test_get_options(self):
2651
index = self.two_graph_index()
2652
self.assertEqual(['fulltext', 'no-eol'], index.get_options('tip'))
2653
self.assertEqual(['fulltext'], index.get_options('parent'))
2655
def test_get_parents_with_ghosts(self):
2656
index = self.two_graph_index()
2657
self.assertEqual((), index.get_parents_with_ghosts('parent'))
2658
# and errors on ghosts.
2659
self.assertRaises(errors.RevisionNotPresent,
2660
index.get_parents_with_ghosts, 'ghost')
2662
def test_check_versions_present(self):
2663
index = self.two_graph_index()
2664
self.assertRaises(RevisionNotPresent, index.check_versions_present,
2666
self.assertRaises(RevisionNotPresent, index.check_versions_present,
2667
['tail', 'missing'])
2668
index.check_versions_present(['tail', 'separate'])
2670
def catch_add(self, entries):
2671
self.caught_entries.append(entries)
2673
def test_add_no_callback_errors(self):
2674
index = self.two_graph_index()
2675
self.assertRaises(errors.ReadOnlyError, index.add_version,
2676
'new', 'fulltext,no-eol', (None, 50, 60), ['separate'])
2678
def test_add_version_smoke(self):
2679
index = self.two_graph_index(catch_adds=True)
2680
index.add_version('new', 'fulltext,no-eol', (None, 50, 60), [])
2681
self.assertEqual([[(('new', ), 'N50 60')]],
2682
self.caught_entries)
2684
def test_add_version_delta_not_delta_index(self):
2685
index = self.two_graph_index(catch_adds=True)
2686
self.assertRaises(errors.KnitCorrupt, index.add_version,
2687
'new', 'no-eol,line-delta', (None, 0, 100), [])
2688
self.assertEqual([], self.caught_entries)
2690
def test_add_version_same_dup(self):
2691
index = self.two_graph_index(catch_adds=True)
2692
# options can be spelt two different ways
2693
index.add_version('tip', 'fulltext,no-eol', (None, 0, 100), [])
2694
index.add_version('tip', 'no-eol,fulltext', (None, 0, 100), [])
2695
# but neither should have added data.
2696
self.assertEqual([[], []], self.caught_entries)
2698
def test_add_version_different_dup(self):
2699
index = self.two_graph_index(catch_adds=True)
2701
self.assertRaises(errors.KnitCorrupt, index.add_version,
2702
'tip', 'no-eol,line-delta', (None, 0, 100), [])
2703
self.assertRaises(errors.KnitCorrupt, index.add_version,
2704
'tip', 'line-delta,no-eol', (None, 0, 100), [])
2705
self.assertRaises(errors.KnitCorrupt, index.add_version,
2706
'tip', 'fulltext', (None, 0, 100), [])
2708
self.assertRaises(errors.KnitCorrupt, index.add_version,
2709
'tip', 'fulltext,no-eol', (None, 50, 100), [])
2710
self.assertRaises(errors.KnitCorrupt, index.add_version,
2711
'tip', 'fulltext,no-eol', (None, 0, 1000), [])
2713
self.assertRaises(errors.KnitCorrupt, index.add_version,
2714
'tip', 'fulltext,no-eol', (None, 0, 100), ['parent'])
2715
self.assertEqual([], self.caught_entries)
2717
def test_add_versions(self):
2718
index = self.two_graph_index(catch_adds=True)
2719
index.add_versions([
2720
('new', 'fulltext,no-eol', (None, 50, 60), []),
2721
('new2', 'fulltext', (None, 0, 6), []),
2723
self.assertEqual([(('new', ), 'N50 60'), (('new2', ), ' 0 6')],
2724
sorted(self.caught_entries[0]))
2725
self.assertEqual(1, len(self.caught_entries))
2727
def test_add_versions_delta_not_delta_index(self):
2728
index = self.two_graph_index(catch_adds=True)
2729
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2730
[('new', 'no-eol,line-delta', (None, 0, 100), ['parent'])])
2731
self.assertEqual([], self.caught_entries)
2733
def test_add_versions_parents_not_parents_index(self):
2734
index = self.two_graph_index(catch_adds=True)
2735
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2736
[('new', 'no-eol,fulltext', (None, 0, 100), ['parent'])])
2737
self.assertEqual([], self.caught_entries)
2739
def test_add_versions_random_id_accepted(self):
2740
index = self.two_graph_index(catch_adds=True)
2741
index.add_versions([], random_id=True)
2743
def test_add_versions_same_dup(self):
2744
index = self.two_graph_index(catch_adds=True)
2745
# options can be spelt two different ways
2746
index.add_versions([('tip', 'fulltext,no-eol', (None, 0, 100), [])])
2747
index.add_versions([('tip', 'no-eol,fulltext', (None, 0, 100), [])])
2748
# but neither should have added data.
2749
self.assertEqual([[], []], self.caught_entries)
2751
def test_add_versions_different_dup(self):
2752
index = self.two_graph_index(catch_adds=True)
2754
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2755
[('tip', 'no-eol,line-delta', (None, 0, 100), [])])
2756
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2757
[('tip', 'line-delta,no-eol', (None, 0, 100), [])])
2758
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2759
[('tip', 'fulltext', (None, 0, 100), [])])
2761
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2762
[('tip', 'fulltext,no-eol', (None, 50, 100), [])])
2763
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2764
[('tip', 'fulltext,no-eol', (None, 0, 1000), [])])
2766
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2767
[('tip', 'fulltext,no-eol', (None, 0, 100), ['parent'])])
2768
# change options in the second record
2769
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2770
[('tip', 'fulltext,no-eol', (None, 0, 100), []),
2771
('tip', 'no-eol,line-delta', (None, 0, 100), [])])
2772
self.assertEqual([], self.caught_entries)
2774
def test_iter_parents(self):
2775
index = self.two_graph_index()
2776
self.assertEqual(set([
2777
('tip', ()), ('tail', ()), ('parent', ()), ('separate', ())
2779
set(index.iter_parents(['tip', 'tail', 'ghost', 'parent', 'separate'])))
2780
self.assertEqual(set([('tip', ())]),
2781
set(index.iter_parents(['tip'])))
2782
self.assertEqual(set(),
2783
set(index.iter_parents([])))
2786
class TestPackKnits(KnitTests):
2787
"""Tests that use a _PackAccess and KnitGraphIndex."""
2789
def test_get_data_stream_packs_ignores_pack_overhead(self):
2790
# Packs have an encoding overhead that should not be included in the
2791
# 'size' field of a data stream, because it is not returned by the
2792
# raw_reading functions - it is why index_memo's are opaque, and
2793
# get_data_stream was abusing this.
2794
packname = 'test.pack'
2795
transport = self.get_transport()
2796
def write_data(bytes):
2797
transport.append_bytes(packname, bytes)
2798
writer = pack.ContainerWriter(write_data)
2800
index = InMemoryGraphIndex(2)
2801
knit_index = KnitGraphIndex(index, add_callback=index.add_nodes,
2803
indices = {index:(transport, packname)}
2804
access = _PackAccess(indices, writer=(writer, index))
2805
k = KnitVersionedFile('test', get_transport('.'),
2806
delta=True, create=True, index=knit_index, access_method=access)
2807
# insert something into the knit
2808
k.add_lines('text-1', [], ["foo\n"])
2809
# get a data stream for it
2810
stream = k.get_data_stream(['text-1'])
2811
# if the stream has been incorrectly assembled, we will get a short read
2812
# reading from the stream (as streams have no trailer)
2813
expected_length = stream[1][0][2]
2814
# we use -1 to do the read, so that if a trailer is added this test
2815
# will fail and we'll adjust it to handle that case correctly, rather
2816
# than allowing an over-read that is bogus.
2817
self.assertEqual(expected_length, len(stream[2](-1)))
2820
class Test_StreamIndex(KnitTests):
2822
def get_index(self, knit, stream):
2823
"""Get a _StreamIndex from knit and stream."""
2824
return knit._knit_from_datastream(stream)._index
2826
def assertIndexVersions(self, knit, versions):
2827
"""Check that the _StreamIndex versions are those of the stream."""
2828
index = self.get_index(knit, knit.get_data_stream(versions))
2829
self.assertEqual(set(index.get_versions()), set(versions))
2830
# check we didn't get duplicates
2831
self.assertEqual(len(index.get_versions()), len(versions))
2833
def assertIndexAncestry(self, knit, ancestry_versions, versions, result):
2834
"""Check the result of a get_ancestry call on knit."""
2835
index = self.get_index(knit, knit.get_data_stream(versions))
2838
set(index.get_ancestry(ancestry_versions, False)))
2840
def assertIterParents(self, knit, versions, parent_versions, result):
2841
"""Check the result of an iter_parents call on knit."""
2842
index = self.get_index(knit, knit.get_data_stream(versions))
2843
self.assertEqual(result, index.iter_parents(parent_versions))
2845
def assertGetMethod(self, knit, versions, version, result):
2846
index = self.get_index(knit, knit.get_data_stream(versions))
2847
self.assertEqual(result, index.get_method(version))
2849
def assertGetOptions(self, knit, version, options):
2850
index = self.get_index(knit, knit.get_data_stream(version))
2851
self.assertEqual(options, index.get_options(version))
2853
def assertGetPosition(self, knit, versions, version, result):
2854
index = self.get_index(knit, knit.get_data_stream(versions))
2855
if result[1] is None:
2856
result = (result[0], index, result[2], result[3])
2857
self.assertEqual(result, index.get_position(version))
2859
def assertGetParentsWithGhosts(self, knit, versions, version, parents):
2860
index = self.get_index(knit, knit.get_data_stream(versions))
2861
self.assertEqual(parents, index.get_parents_with_ghosts(version))
2863
def make_knit_with_4_versions_2_dags(self):
2864
knit = self.make_test_knit()
2865
knit.add_lines('a', [], ["foo"])
2866
knit.add_lines('b', [], [])
2867
knit.add_lines('c', ['b', 'a'], [])
2868
knit.add_lines_with_ghosts('d', ['e', 'f'], [])
2871
def test_versions(self):
2872
"""The versions of a StreamIndex are those of the datastream."""
2873
knit = self.make_knit_with_4_versions_2_dags()
2874
# ask for most permutations, which catches bugs like falling back to the
2875
# target knit, or showing ghosts, etc.
2876
self.assertIndexVersions(knit, [])
2877
self.assertIndexVersions(knit, ['a'])
2878
self.assertIndexVersions(knit, ['b'])
2879
self.assertIndexVersions(knit, ['c'])
2880
self.assertIndexVersions(knit, ['d'])
2881
self.assertIndexVersions(knit, ['a', 'b'])
2882
self.assertIndexVersions(knit, ['b', 'c'])
2883
self.assertIndexVersions(knit, ['a', 'c'])
2884
self.assertIndexVersions(knit, ['a', 'b', 'c'])
2885
self.assertIndexVersions(knit, ['a', 'b', 'c', 'd'])
2887
def test_construct(self):
2888
"""Constructing a StreamIndex generates index data."""
2889
data_list = [('text-a', ['fulltext'], 127, []),
2890
('text-b', ['option'], 128, ['text-c'])]
2891
index = _StreamIndex(data_list, None)
2892
self.assertEqual({'text-a':(['fulltext'], (0, 127), []),
2893
'text-b':(['option'], (127, 127 + 128), ['text-c'])},
2896
def test_get_ancestry(self):
2897
knit = self.make_knit_with_4_versions_2_dags()
2898
self.assertIndexAncestry(knit, ['a'], ['a'], ['a'])
2899
self.assertIndexAncestry(knit, ['b'], ['b'], ['b'])
2900
self.assertIndexAncestry(knit, ['c'], ['c'], ['c'])
2901
self.assertIndexAncestry(knit, ['c'], ['a', 'b', 'c'],
2902
set(['a', 'b', 'c']))
2903
self.assertIndexAncestry(knit, ['c', 'd'], ['a', 'b', 'c', 'd'],
2904
set(['a', 'b', 'c', 'd']))
2906
def test_get_method(self):
2907
knit = self.make_knit_with_4_versions_2_dags()
2908
self.assertGetMethod(knit, ['a'], 'a', 'fulltext')
2909
self.assertGetMethod(knit, ['c'], 'c', 'line-delta')
2910
# get_method on a basis that is not in the datastream (but in the
2911
# backing knit) returns 'fulltext', because thats what we'll create as
2913
self.assertGetMethod(knit, ['c'], 'b', 'fulltext')
2915
def test_iter_parents(self):
2916
knit = self.make_knit_with_4_versions_2_dags()
2917
self.assertIterParents(knit, ['a'], ['a'], [('a', ())])
2918
self.assertIterParents(knit, ['a', 'b'], ['a', 'b'],
2919
[('a', ()), ('b', ())])
2920
self.assertIterParents(knit, ['a', 'b', 'c'], ['a', 'b', 'c'],
2921
[('a', ()), ('b', ()), ('c', ('b', 'a'))])
2922
self.assertIterParents(knit, ['a', 'b', 'c', 'd'],
2923
['a', 'b', 'c', 'd'],
2924
[('a', ()), ('b', ()), ('c', ('b', 'a')), ('d', ('e', 'f'))])
2925
self.assertIterParents(knit, ['c'], ['a', 'b', 'c'],
2926
[('c', ('b', 'a'))])
2928
def test_get_options(self):
2929
knit = self.make_knit_with_4_versions_2_dags()
2930
self.assertGetOptions(knit, 'a', ['no-eol', 'fulltext'])
2931
self.assertGetOptions(knit, 'c', ['line-delta'])
2933
def test_get_parents_with_ghosts(self):
2934
knit = self.make_knit_with_4_versions_2_dags()
2935
self.assertGetParentsWithGhosts(knit, ['a'], 'a', ())
2936
self.assertGetParentsWithGhosts(knit, ['c'], 'c', ('b', 'a'))
2937
self.assertGetParentsWithGhosts(knit, ['d'], 'd', ('e', 'f'))
2939
def test_get_position(self):
2940
knit = self.make_knit_with_4_versions_2_dags()
2941
# get_position returns (thunk_flag, index(can be None), start, end) for
2942
# _StreamAccess to use.
2943
self.assertGetPosition(knit, ['a'], 'a', (False, None, 0, 78))
2944
self.assertGetPosition(knit, ['a', 'c'], 'c', (False, None, 78, 156))
2945
# get_position on a text that is not in the datastream (but in the
2946
# backing knit) returns (True, 'versionid', None, None) - and then the
2947
# access object can construct the relevant data as needed.
2948
self.assertGetPosition(knit, ['a', 'c'], 'b', (True, 'b', None, None))
2951
class Test_StreamAccess(KnitTests):
2953
def get_index_access(self, knit, stream):
2954
"""Get a _StreamAccess from knit and stream."""
2955
knit = knit._knit_from_datastream(stream)
2956
return knit._index, knit._data._access
2958
def assertGetRawRecords(self, knit, versions):
2959
index, access = self.get_index_access(knit,
2960
knit.get_data_stream(versions))
2961
# check that every version asked for can be obtained from the resulting
2965
for version in versions:
2966
memos.append(knit._index.get_position(version))
2968
for version, data in zip(
2969
versions, knit._data._access.get_raw_records(memos)):
2970
original[version] = data
2972
for version in versions:
2973
memos.append(index.get_position(version))
2975
for version, data in zip(versions, access.get_raw_records(memos)):
2976
streamed[version] = data
2977
self.assertEqual(original, streamed)
2979
for version in versions:
2980
data = list(access.get_raw_records(
2981
[index.get_position(version)]))[0]
2982
self.assertEqual(original[version], data)
2984
def make_knit_with_two_versions(self):
2985
knit = self.make_test_knit()
2986
knit.add_lines('a', [], ["foo"])
2987
knit.add_lines('b', [], ["bar"])
2990
def test_get_raw_records(self):
2991
knit = self.make_knit_with_two_versions()
2992
self.assertGetRawRecords(knit, ['a', 'b'])
2993
self.assertGetRawRecords(knit, ['a'])
2994
self.assertGetRawRecords(knit, ['b'])
2996
def test_get_raw_record_from_backing_knit(self):
2997
# the thunk layer should create an artificial A on-demand when needed.
2998
source_knit = self.make_test_knit(name='plain', annotate=False)
2999
target_knit = self.make_test_knit(name='annotated', annotate=True)
3000
source_knit.add_lines("A", [], ["Foo\n"])
3001
# Give the target A, so we can try to thunk across to it.
3002
target_knit.join(source_knit)
3003
index, access = self.get_index_access(target_knit,
3004
source_knit.get_data_stream([]))
3005
raw_data = list(access.get_raw_records([(True, "A", None, None)]))[0]
3006
df = GzipFile(mode='rb', fileobj=StringIO(raw_data))
3008
'version A 1 5d36b88bb697a2d778f024048bafabd443d74503\n'
3012
def test_asking_for_thunk_stream_is_not_plain_errors(self):
3013
knit = self.make_test_knit(name='annotated', annotate=True)
3014
knit.add_lines("A", [], ["Foo\n"])
3015
index, access = self.get_index_access(knit,
3016
knit.get_data_stream([]))
3017
self.assertRaises(errors.KnitCorrupt,
3018
list, access.get_raw_records([(True, "A", None, None)]))
added
removed
bzrlib/tests/test_knit.py
