~bzr-pqm/bzr/bzr.dev
» Revision
3376.2.8
(compared to revision 3641.5.3)
: bzrlib/tests/test_knit.py
« back to all changes in this revision
Viewing changes to bzrlib/tests/test_knit.py
- browse files at revision 3376.2.8
- compare with another revision
- download diff
- download tarball
- view history from revision 3376.2.8
- Committer: Martin Pool
- Date: 2008-05-08 04:12:06 UTC
- mto: This revision was merged to the branch mainline in revision 3415.
- Revision ID: mbp@sourcefrog.net-20080508041206-tkrr8ucmcyrlzkum
Some review cleanups for assertion removal
- files added:
- bzrlib/store/revision/__init__.py
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/revisionstore_implementations
- files removed:
- bzrlib/_btree_serializer_c.pyx
- bzrlib/tests/per_repository_reference
- doc/es
- doc/es/guia-desarrollador
- doc/es/guia-usuario
- doc/es/mini-tutorial
- doc/es/notas-version
- doc/es/referencia
- doc/es/referencia-rapida
- files renamed:
- doc/en/user-guide/part2_intro.txt => doc/en/user-guide/best_practice_intro.txt
- doc/en/user-guide/zen.txt => doc/en/user-guide/revnos.txt
- files modified:
- .bzrignore
added
removed
bzrlib/tests/test_knit.py
26
26
errors,
27
27
generate_ids,
28
28
knit,
29
multiparent,
30
29
pack,
31
30
)
32
31
from bzrlib.errors import (
38
37
from bzrlib.index import *
39
38
from bzrlib.knit import (
40
39
AnnotatedKnitContent,
40
DATA_SUFFIX,
41
INDEX_SUFFIX,
41
42
KnitContent,
43
KnitGraphIndex,
44
KnitVersionedFile,
45
KnitPlainFactory,
46
KnitAnnotateFactory,
47
_KnitAccess,
48
_KnitData,
49
_KnitIndex,
50
make_file_knit,
51
_PackAccess,
52
PlainKnitContent,
53
_StreamAccess,
54
_StreamIndex,
55
WeaveToKnit,
42
56
KnitSequenceMatcher,
43
KnitVersionedFiles,
44
PlainKnitContent,
45
_DirectPackAccess,
46
_KndxIndex,
47
_KnitGraphIndex,
48
_KnitKeyAccess,
49
make_file_factory,
50
57
)
51
58
from bzrlib.osutils import split_lines
52
59
from bzrlib.symbol_versioning import one_four
53
60
from bzrlib.tests import (
54
61
Feature,
55
KnownFailure,
56
62
TestCase,
57
63
TestCaseWithMemoryTransport,
58
64
TestCaseWithTransport,
60
66
from bzrlib.transport import get_transport
61
67
from bzrlib.transport.memory import MemoryTransport
62
68
from bzrlib.tuned_gzip import GzipFile
63
from bzrlib.versionedfile import (
64
AbsentContentFactory,
65
ConstantMapper,
66
RecordingVersionedFilesDecorator,
67
)
69
from bzrlib.util import bencode
70
from bzrlib.weave import Weave
68
71
69
72
70
73
class _CompiledKnitFeature(Feature):
145
148
self.assertDerivedBlocksEqual('a\nb\nc', 'a\nb\nc\n', noeol=True)
146
149
147
150
148
TEXT_1 = """\
149
Banana cup cakes:
150
151
- bananas
152
- eggs
153
- broken tea cups
154
"""
155
156
TEXT_1A = """\
157
Banana cup cake recipe
158
(serves 6)
159
160
- bananas
161
- eggs
162
- broken tea cups
163
- self-raising flour
164
"""
165
166
TEXT_1B = """\
167
Banana cup cake recipe
168
169
- bananas (do not use plantains!!!)
170
- broken tea cups
171
- flour
172
"""
173
174
delta_1_1a = """\
175
0,1,2
176
Banana cup cake recipe
177
(serves 6)
178
5,5,1
179
- self-raising flour
180
"""
181
182
TEXT_2 = """\
183
Boeuf bourguignon
184
185
- beef
186
- red wine
187
- small onions
188
- carrot
189
- mushrooms
190
"""
191
192
193
151
class TestPlainKnitContent(TestCase, KnitContentTestsMixin):
194
152
195
153
def _make_content(self, lines):
274
232
class KnitRecordAccessTestsMixin(object):
275
233
"""Tests for getting and putting knit records."""
276
234
235
def assertAccessExists(self, access):
236
"""Ensure the data area for access has been initialised/exists."""
237
raise NotImplementedError(self.assertAccessExists)
238
277
239
def test_add_raw_records(self):
278
240
"""Add_raw_records adds records retrievable later."""
279
241
access = self.get_access()
280
memos = access.add_raw_records([('key', 10)], '1234567890')
242
memos = access.add_raw_records([10], '1234567890')
281
243
self.assertEqual(['1234567890'], list(access.get_raw_records(memos)))
282
244
283
245
def test_add_several_raw_records(self):
284
246
"""add_raw_records with many records and read some back."""
285
247
access = self.get_access()
286
memos = access.add_raw_records([('key', 10), ('key2', 2), ('key3', 5)],
287
'12345678901234567')
248
memos = access.add_raw_records([10, 2, 5], '12345678901234567')
288
249
self.assertEqual(['1234567890', '12', '34567'],
289
250
list(access.get_raw_records(memos)))
290
251
self.assertEqual(['1234567890'],
296
257
self.assertEqual(['1234567890', '34567'],
297
258
list(access.get_raw_records(memos[0:1] + memos[2:3])))
298
259
260
def test_create(self):
261
"""create() should make a file on disk."""
262
access = self.get_access()
263
access.create()
264
self.assertAccessExists(access)
265
266
def test_open_file(self):
267
"""open_file never errors."""
268
access = self.get_access()
269
access.open_file()
270
299
271
300
272
class TestKnitKnitAccess(TestCaseWithMemoryTransport, KnitRecordAccessTestsMixin):
301
273
"""Tests for the .kndx implementation."""
302
274
275
def assertAccessExists(self, access):
276
self.assertNotEqual(None, access.open_file())
277
303
278
def get_access(self):
304
279
"""Get a .knit style access instance."""
305
mapper = ConstantMapper("foo")
306
access = _KnitKeyAccess(self.get_transport(), mapper)
280
access = _KnitAccess(self.get_transport(), "foo.knit", None, None,
281
False, False)
307
282
return access
308
283
309
284
310
285
class TestPackKnitAccess(TestCaseWithMemoryTransport, KnitRecordAccessTestsMixin):
311
286
"""Tests for the pack based access."""
312
287
288
def assertAccessExists(self, access):
289
# as pack based access has no backing unless an index maps data, this
290
# is a no-op.
291
pass
292
313
293
def get_access(self):
314
294
return self._get_access()[0]
315
295
319
299
transport.append_bytes(packname, bytes)
320
300
writer = pack.ContainerWriter(write_data)
321
301
writer.begin()
322
access = _DirectPackAccess({})
323
access.set_writer(writer, index, (transport, packname))
302
indices = {index:(transport, packname)}
303
access = _PackAccess(indices, writer=(writer, index))
324
304
return access, writer
325
305
326
306
def test_read_from_several_packs(self):
327
307
access, writer = self._get_access()
328
308
memos = []
329
memos.extend(access.add_raw_records([('key', 10)], '1234567890'))
309
memos.extend(access.add_raw_records([10], '1234567890'))
330
310
writer.end()
331
311
access, writer = self._get_access('pack2', 'FOOBAR')
332
memos.extend(access.add_raw_records([('key', 5)], '12345'))
312
memos.extend(access.add_raw_records([5], '12345'))
333
313
writer.end()
334
314
access, writer = self._get_access('pack3', 'BAZ')
335
memos.extend(access.add_raw_records([('key', 5)], 'alpha'))
315
memos.extend(access.add_raw_records([5], 'alpha'))
336
316
writer.end()
337
317
transport = self.get_transport()
338
access = _DirectPackAccess({"FOO":(transport, 'packfile'),
318
access = _PackAccess({"FOO":(transport, 'packfile'),
339
319
"FOOBAR":(transport, 'pack2'),
340
320
"BAZ":(transport, 'pack3')})
341
321
self.assertEqual(['1234567890', '12345', 'alpha'],
351
331
352
332
def test_set_writer(self):
353
333
"""The writer should be settable post construction."""
354
access = _DirectPackAccess({})
334
access = _PackAccess({})
355
335
transport = self.get_transport()
356
336
packname = 'packfile'
357
337
index = 'foo'
360
340
writer = pack.ContainerWriter(write_data)
361
341
writer.begin()
362
342
access.set_writer(writer, index, (transport, packname))
363
memos = access.add_raw_records([('key', 10)], '1234567890')
343
memos = access.add_raw_records([10], '1234567890')
364
344
writer.end()
365
345
self.assertEqual(['1234567890'], list(access.get_raw_records(memos)))
366
346
382
362
'end rev-id-1\n'
383
363
% (sha1sum,))
384
364
transport = MockTransport([gz_txt])
385
access = _KnitKeyAccess(transport, ConstantMapper('filename'))
386
knit = KnitVersionedFiles(None, access)
387
records = [(('rev-id-1',), (('rev-id-1',), 0, len(gz_txt)))]
388
389
contents = list(knit._read_records_iter(records))
390
self.assertEqual([(('rev-id-1',), ['foo\n', 'bar\n'],
391
'4e48e2c9a3d2ca8a708cb0cc545700544efb5021')], contents)
392
393
raw_contents = list(knit._read_records_iter_raw(records))
394
self.assertEqual([(('rev-id-1',), gz_txt, sha1sum)], raw_contents)
365
access = _KnitAccess(transport, 'filename', None, None, False, False)
366
data = _KnitData(access=access)
367
records = [('rev-id-1', (None, 0, len(gz_txt)))]
368
369
contents = data.read_records(records)
370
self.assertEqual({'rev-id-1':(['foo\n', 'bar\n'], sha1sum)}, contents)
371
372
raw_contents = list(data.read_records_iter_raw(records))
373
self.assertEqual([('rev-id-1', gz_txt)], raw_contents)
395
374
396
375
def test_not_enough_lines(self):
397
376
sha1sum = sha.new('foo\n').hexdigest()
401
380
'end rev-id-1\n'
402
381
% (sha1sum,))
403
382
transport = MockTransport([gz_txt])
404
access = _KnitKeyAccess(transport, ConstantMapper('filename'))
405
knit = KnitVersionedFiles(None, access)
406
records = [(('rev-id-1',), (('rev-id-1',), 0, len(gz_txt)))]
407
self.assertRaises(errors.KnitCorrupt, list,
408
knit._read_records_iter(records))
383
access = _KnitAccess(transport, 'filename', None, None, False, False)
384
data = _KnitData(access=access)
385
records = [('rev-id-1', (None, 0, len(gz_txt)))]
386
self.assertRaises(errors.KnitCorrupt, data.read_records, records)
409
387
410
388
# read_records_iter_raw won't detect that sort of mismatch/corruption
411
raw_contents = list(knit._read_records_iter_raw(records))
412
self.assertEqual([(('rev-id-1',), gz_txt, sha1sum)], raw_contents)
389
raw_contents = list(data.read_records_iter_raw(records))
390
self.assertEqual([('rev-id-1', gz_txt)], raw_contents)
413
391
414
392
def test_too_many_lines(self):
415
393
sha1sum = sha.new('foo\nbar\n').hexdigest()
420
398
'end rev-id-1\n'
421
399
% (sha1sum,))
422
400
transport = MockTransport([gz_txt])
423
access = _KnitKeyAccess(transport, ConstantMapper('filename'))
424
knit = KnitVersionedFiles(None, access)
425
records = [(('rev-id-1',), (('rev-id-1',), 0, len(gz_txt)))]
426
self.assertRaises(errors.KnitCorrupt, list,
427
knit._read_records_iter(records))
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)
428
405
429
406
# read_records_iter_raw won't detect that sort of mismatch/corruption
430
raw_contents = list(knit._read_records_iter_raw(records))
431
self.assertEqual([(('rev-id-1',), gz_txt, sha1sum)], raw_contents)
407
raw_contents = list(data.read_records_iter_raw(records))
408
self.assertEqual([('rev-id-1', gz_txt)], raw_contents)
432
409
433
410
def test_mismatched_version_id(self):
434
411
sha1sum = sha.new('foo\nbar\n').hexdigest()
438
415
'end rev-id-1\n'
439
416
% (sha1sum,))
440
417
transport = MockTransport([gz_txt])
441
access = _KnitKeyAccess(transport, ConstantMapper('filename'))
442
knit = KnitVersionedFiles(None, access)
418
access = _KnitAccess(transport, 'filename', None, None, False, False)
419
data = _KnitData(access=access)
443
420
# We are asking for rev-id-2, but the data is rev-id-1
444
records = [(('rev-id-2',), (('rev-id-2',), 0, len(gz_txt)))]
445
self.assertRaises(errors.KnitCorrupt, list,
446
knit._read_records_iter(records))
421
records = [('rev-id-2', (None, 0, len(gz_txt)))]
422
self.assertRaises(errors.KnitCorrupt, data.read_records, records)
447
423
448
# read_records_iter_raw detects mismatches in the header
424
# read_records_iter_raw will notice if we request the wrong version.
449
425
self.assertRaises(errors.KnitCorrupt, list,
450
knit._read_records_iter_raw(records))
426
data.read_records_iter_raw(records))
451
427
452
428
def test_uncompressed_data(self):
453
429
sha1sum = sha.new('foo\nbar\n').hexdigest()
457
433
'end rev-id-1\n'
458
434
% (sha1sum,))
459
435
transport = MockTransport([txt])
460
access = _KnitKeyAccess(transport, ConstantMapper('filename'))
461
knit = KnitVersionedFiles(None, access)
462
records = [(('rev-id-1',), (('rev-id-1',), 0, len(txt)))]
436
access = _KnitAccess(transport, 'filename', None, None, False, False)
437
data = _KnitData(access=access)
438
records = [('rev-id-1', (None, 0, len(txt)))]
463
439
464
440
# We don't have valid gzip data ==> corrupt
465
self.assertRaises(errors.KnitCorrupt, list,
466
knit._read_records_iter(records))
441
self.assertRaises(errors.KnitCorrupt, data.read_records, records)
467
442
468
443
# read_records_iter_raw will notice the bad data
469
444
self.assertRaises(errors.KnitCorrupt, list,
470
knit._read_records_iter_raw(records))
445
data.read_records_iter_raw(records))
471
446
472
447
def test_corrupted_data(self):
473
448
sha1sum = sha.new('foo\nbar\n').hexdigest()
479
454
# Change 2 bytes in the middle to \xff
480
455
gz_txt = gz_txt[:10] + '\xff\xff' + gz_txt[12:]
481
456
transport = MockTransport([gz_txt])
482
access = _KnitKeyAccess(transport, ConstantMapper('filename'))
483
knit = KnitVersionedFiles(None, access)
484
records = [(('rev-id-1',), (('rev-id-1',), 0, len(gz_txt)))]
485
self.assertRaises(errors.KnitCorrupt, list,
486
knit._read_records_iter(records))
487
# read_records_iter_raw will barf on bad gz data
488
self.assertRaises(errors.KnitCorrupt, list,
489
knit._read_records_iter_raw(records))
457
access = _KnitAccess(transport, 'filename', None, None, False, False)
458
data = _KnitData(access=access)
459
records = [('rev-id-1', (None, 0, len(gz_txt)))]
460
461
self.assertRaises(errors.KnitCorrupt, data.read_records, records)
462
463
# read_records_iter_raw will notice if we request the wrong version.
464
self.assertRaises(errors.KnitCorrupt, list,
465
data.read_records_iter_raw(records))
490
466
491
467
492
468
class LowLevelKnitIndexTests(TestCase):
493
469
494
def get_knit_index(self, transport, name, mode):
495
mapper = ConstantMapper(name)
470
def get_knit_index(self, *args, **kwargs):
496
471
orig = knit._load_data
497
472
def reset():
498
473
knit._load_data = orig
499
474
self.addCleanup(reset)
500
475
from bzrlib._knit_load_data_py import _load_data_py
501
476
knit._load_data = _load_data_py
502
allow_writes = lambda: 'w' in mode
503
return _KndxIndex(transport, mapper, lambda:None, allow_writes, lambda:True)
477
return _KnitIndex(get_scope=lambda:None, *args, **kwargs)
478
479
def test_no_such_file(self):
480
transport = MockTransport()
481
482
self.assertRaises(NoSuchFile, self.get_knit_index,
483
transport, "filename", "r")
484
self.assertRaises(NoSuchFile, self.get_knit_index,
485
transport, "filename", "w", create=False)
504
486
505
487
def test_create_file(self):
506
488
transport = MockTransport()
507
index = self.get_knit_index(transport, "filename", "w")
508
index.keys()
509
call = transport.calls.pop(0)
510
# call[1][1] is a StringIO - we can't test it by simple equality.
511
self.assertEqual('put_file_non_atomic', call[0])
512
self.assertEqual('filename.kndx', call[1][0])
513
# With no history, _KndxIndex writes a new index:
514
self.assertEqual(_KndxIndex.HEADER,
515
call[1][1].getvalue())
516
self.assertEqual({'create_parent_dir': True}, call[2])
489
490
index = self.get_knit_index(transport, "filename", "w",
491
file_mode="wb", create=True)
492
self.assertEqual(
493
("put_bytes_non_atomic",
494
("filename", index.HEADER), {"mode": "wb"}),
495
transport.calls.pop(0))
496
497
def test_delay_create_file(self):
498
transport = MockTransport()
499
500
index = self.get_knit_index(transport, "filename", "w",
501
create=True, file_mode="wb", create_parent_dir=True,
502
delay_create=True, dir_mode=0777)
503
self.assertEqual([], transport.calls)
504
505
index.add_versions([])
506
name, (filename, f), kwargs = transport.calls.pop(0)
507
self.assertEqual("put_file_non_atomic", name)
508
self.assertEqual(
509
{"dir_mode": 0777, "create_parent_dir": True, "mode": "wb"},
510
kwargs)
511
self.assertEqual("filename", filename)
512
self.assertEqual(index.HEADER, f.read())
513
514
index.add_versions([])
515
self.assertEqual(("append_bytes", ("filename", ""), {}),
516
transport.calls.pop(0))
517
517
518
518
def test_read_utf8_version_id(self):
519
519
unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
520
520
utf8_revision_id = unicode_revision_id.encode('utf-8')
521
521
transport = MockTransport([
522
_KndxIndex.HEADER,
522
_KnitIndex.HEADER,
523
523
'%s option 0 1 :' % (utf8_revision_id,)
524
524
])
525
525
index = self.get_knit_index(transport, "filename", "r")
526
# _KndxIndex is a private class, and deals in utf8 revision_ids, not
526
# _KnitIndex is a private class, and deals in utf8 revision_ids, not
527
527
# Unicode revision_ids.
528
self.assertEqual({(utf8_revision_id,):()},
529
index.get_parent_map(index.keys()))
530
self.assertFalse((unicode_revision_id,) in index.keys())
528
self.assertTrue(index.has_version(utf8_revision_id))
529
self.assertFalse(index.has_version(unicode_revision_id))
531
530
532
531
def test_read_utf8_parents(self):
533
532
unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
534
533
utf8_revision_id = unicode_revision_id.encode('utf-8')
535
534
transport = MockTransport([
536
_KndxIndex.HEADER,
535
_KnitIndex.HEADER,
537
536
"version option 0 1 .%s :" % (utf8_revision_id,)
538
537
])
539
538
index = self.get_knit_index(transport, "filename", "r")
540
self.assertEqual({("version",):((utf8_revision_id,),)},
541
index.get_parent_map(index.keys()))
539
self.assertEqual((utf8_revision_id,),
540
index.get_parents_with_ghosts("version"))
542
541
543
542
def test_read_ignore_corrupted_lines(self):
544
543
transport = MockTransport([
545
_KndxIndex.HEADER,
544
_KnitIndex.HEADER,
546
545
"corrupted",
547
546
"corrupted options 0 1 .b .c ",
548
547
"version options 0 1 :"
549
548
])
550
549
index = self.get_knit_index(transport, "filename", "r")
551
self.assertEqual(1, len(index.keys()))
552
self.assertEqual(set([("version",)]), index.keys())
550
self.assertEqual(1, index.num_versions())
551
self.assertTrue(index.has_version("version"))
553
552
554
553
def test_read_corrupted_header(self):
555
554
transport = MockTransport(['not a bzr knit index header\n'])
556
index = self.get_knit_index(transport, "filename", "r")
557
self.assertRaises(KnitHeaderError, index.keys)
555
self.assertRaises(KnitHeaderError,
556
self.get_knit_index, transport, "filename", "r")
558
557
559
558
def test_read_duplicate_entries(self):
560
559
transport = MockTransport([
561
_KndxIndex.HEADER,
560
_KnitIndex.HEADER,
562
561
"parent options 0 1 :",
563
562
"version options1 0 1 0 :",
564
563
"version options2 1 2 .other :",
565
564
"version options3 3 4 0 .other :"
566
565
])
567
566
index = self.get_knit_index(transport, "filename", "r")
568
self.assertEqual(2, len(index.keys()))
567
self.assertEqual(2, index.num_versions())
569
568
# check that the index used is the first one written. (Specific
570
569
# to KnitIndex style indices.
571
self.assertEqual("1", index._dictionary_compress([("version",)]))
572
self.assertEqual((("version",), 3, 4), index.get_position(("version",)))
573
self.assertEqual(["options3"], index.get_options(("version",)))
574
self.assertEqual({("version",):(("parent",), ("other",))},
575
index.get_parent_map([("version",)]))
570
self.assertEqual("1", index._version_list_to_index(["version"]))
571
self.assertEqual((None, 3, 4), index.get_position("version"))
572
self.assertEqual(["options3"], index.get_options("version"))
573
self.assertEqual(("parent", "other"),
574
index.get_parents_with_ghosts("version"))
576
575
577
576
def test_read_compressed_parents(self):
578
577
transport = MockTransport([
579
_KndxIndex.HEADER,
578
_KnitIndex.HEADER,
580
579
"a option 0 1 :",
581
580
"b option 0 1 0 :",
582
581
"c option 0 1 1 0 :",
583
582
])
584
583
index = self.get_knit_index(transport, "filename", "r")
585
self.assertEqual({("b",):(("a",),), ("c",):(("b",), ("a",))},
586
index.get_parent_map([("b",), ("c",)]))
584
self.assertEqual({"b":("a",), "c":("b", "a")},
585
index.get_parent_map(["b", "c"]))
587
586
588
587
def test_write_utf8_version_id(self):
589
588
unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
590
589
utf8_revision_id = unicode_revision_id.encode('utf-8')
591
590
transport = MockTransport([
592
_KndxIndex.HEADER
591
_KnitIndex.HEADER
593
592
])
594
593
index = self.get_knit_index(transport, "filename", "r")
595
index.add_records([
596
((utf8_revision_id,), ["option"], ((utf8_revision_id,), 0, 1), [])])
597
call = transport.calls.pop(0)
598
# call[1][1] is a StringIO - we can't test it by simple equality.
599
self.assertEqual('put_file_non_atomic', call[0])
600
self.assertEqual('filename.kndx', call[1][0])
601
# With no history, _KndxIndex writes a new index:
602
self.assertEqual(_KndxIndex.HEADER +
603
"\n%s option 0 1 :" % (utf8_revision_id,),
604
call[1][1].getvalue())
605
self.assertEqual({'create_parent_dir': True}, call[2])
594
index.add_version(utf8_revision_id, ["option"], (None, 0, 1), [])
595
self.assertEqual(("append_bytes", ("filename",
596
"\n%s option 0 1 :" % (utf8_revision_id,)),
597
{}),
598
transport.calls.pop(0))
606
599
607
600
def test_write_utf8_parents(self):
608
601
unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
609
602
utf8_revision_id = unicode_revision_id.encode('utf-8')
610
603
transport = MockTransport([
611
_KndxIndex.HEADER
612
])
613
index = self.get_knit_index(transport, "filename", "r")
614
index.add_records([
615
(("version",), ["option"], (("version",), 0, 1), [(utf8_revision_id,)])])
616
call = transport.calls.pop(0)
617
# call[1][1] is a StringIO - we can't test it by simple equality.
618
self.assertEqual('put_file_non_atomic', call[0])
619
self.assertEqual('filename.kndx', call[1][0])
620
# With no history, _KndxIndex writes a new index:
621
self.assertEqual(_KndxIndex.HEADER +
622
"\nversion option 0 1 .%s :" % (utf8_revision_id,),
623
call[1][1].getvalue())
624
self.assertEqual({'create_parent_dir': True}, call[2])
625
626
def test_keys(self):
627
transport = MockTransport([
628
_KndxIndex.HEADER
629
])
630
index = self.get_knit_index(transport, "filename", "r")
631
632
self.assertEqual(set(), index.keys())
633
634
index.add_records([(("a",), ["option"], (("a",), 0, 1), [])])
635
self.assertEqual(set([("a",)]), index.keys())
636
637
index.add_records([(("a",), ["option"], (("a",), 0, 1), [])])
638
self.assertEqual(set([("a",)]), index.keys())
639
640
index.add_records([(("b",), ["option"], (("b",), 0, 1), [])])
641
self.assertEqual(set([("a",), ("b",)]), index.keys())
642
643
def add_a_b(self, index, random_id=None):
644
kwargs = {}
645
if random_id is not None:
646
kwargs["random_id"] = random_id
647
index.add_records([
648
(("a",), ["option"], (("a",), 0, 1), [("b",)]),
649
(("a",), ["opt"], (("a",), 1, 2), [("c",)]),
650
(("b",), ["option"], (("b",), 2, 3), [("a",)])
651
], **kwargs)
652
653
def assertIndexIsAB(self, index):
654
self.assertEqual({
655
('a',): (('c',),),
656
('b',): (('a',),),
657
},
658
index.get_parent_map(index.keys()))
659
self.assertEqual((("a",), 1, 2), index.get_position(("a",)))
660
self.assertEqual((("b",), 2, 3), index.get_position(("b",)))
661
self.assertEqual(["opt"], index.get_options(("a",)))
604
_KnitIndex.HEADER
605
])
606
index = self.get_knit_index(transport, "filename", "r")
607
index.add_version("version", ["option"], (None, 0, 1), [utf8_revision_id])
608
self.assertEqual(("append_bytes", ("filename",
609
"\nversion option 0 1 .%s :" % (utf8_revision_id,)),
610
{}),
611
transport.calls.pop(0))
612
613
def test_get_ancestry(self):
614
transport = MockTransport([
615
_KnitIndex.HEADER,
616
"a option 0 1 :",
617
"b option 0 1 0 .e :",
618
"c option 0 1 1 0 :",
619
"d option 0 1 2 .f :"
620
])
621
index = self.get_knit_index(transport, "filename", "r")
622
623
self.assertEqual([], index.get_ancestry([]))
624
self.assertEqual(["a"], index.get_ancestry(["a"]))
625
self.assertEqual(["a", "b"], index.get_ancestry(["b"]))
626
self.assertEqual(["a", "b", "c"], index.get_ancestry(["c"]))
627
self.assertEqual(["a", "b", "c", "d"], index.get_ancestry(["d"]))
628
self.assertEqual(["a", "b"], index.get_ancestry(["a", "b"]))
629
self.assertEqual(["a", "b", "c"], index.get_ancestry(["a", "c"]))
630
631
self.assertRaises(RevisionNotPresent, index.get_ancestry, ["e"])
632
633
def test_get_ancestry_with_ghosts(self):
634
transport = MockTransport([
635
_KnitIndex.HEADER,
636
"a option 0 1 :",
637
"b option 0 1 0 .e :",
638
"c option 0 1 0 .f .g :",
639
"d option 0 1 2 .h .j .k :"
640
])
641
index = self.get_knit_index(transport, "filename", "r")
642
643
self.assertEqual([], index.get_ancestry_with_ghosts([]))
644
self.assertEqual(["a"], index.get_ancestry_with_ghosts(["a"]))
645
self.assertEqual(["a", "e", "b"],
646
index.get_ancestry_with_ghosts(["b"]))
647
self.assertEqual(["a", "g", "f", "c"],
648
index.get_ancestry_with_ghosts(["c"]))
649
self.assertEqual(["a", "g", "f", "c", "k", "j", "h", "d"],
650
index.get_ancestry_with_ghosts(["d"]))
651
self.assertEqual(["a", "e", "b"],
652
index.get_ancestry_with_ghosts(["a", "b"]))
653
self.assertEqual(["a", "g", "f", "c"],
654
index.get_ancestry_with_ghosts(["a", "c"]))
655
self.assertEqual(
656
["a", "g", "f", "c", "e", "b", "k", "j", "h", "d"],
657
index.get_ancestry_with_ghosts(["b", "d"]))
658
659
self.assertRaises(RevisionNotPresent,
660
index.get_ancestry_with_ghosts, ["e"])
661
662
def test_num_versions(self):
663
transport = MockTransport([
664
_KnitIndex.HEADER
665
])
666
index = self.get_knit_index(transport, "filename", "r")
667
668
self.assertEqual(0, index.num_versions())
669
self.assertEqual(0, len(index))
670
671
index.add_version("a", ["option"], (None, 0, 1), [])
672
self.assertEqual(1, index.num_versions())
673
self.assertEqual(1, len(index))
674
675
index.add_version("a", ["option2"], (None, 1, 2), [])
676
self.assertEqual(1, index.num_versions())
677
self.assertEqual(1, len(index))
678
679
index.add_version("b", ["option"], (None, 0, 1), [])
680
self.assertEqual(2, index.num_versions())
681
self.assertEqual(2, len(index))
682
683
def test_get_versions(self):
684
transport = MockTransport([
685
_KnitIndex.HEADER
686
])
687
index = self.get_knit_index(transport, "filename", "r")
688
689
self.assertEqual([], index.get_versions())
690
691
index.add_version("a", ["option"], (None, 0, 1), [])
692
self.assertEqual(["a"], index.get_versions())
693
694
index.add_version("a", ["option"], (None, 0, 1), [])
695
self.assertEqual(["a"], index.get_versions())
696
697
index.add_version("b", ["option"], (None, 0, 1), [])
698
self.assertEqual(["a", "b"], index.get_versions())
699
700
def test_add_version(self):
701
transport = MockTransport([
702
_KnitIndex.HEADER
703
])
704
index = self.get_knit_index(transport, "filename", "r")
705
706
index.add_version("a", ["option"], (None, 0, 1), ["b"])
707
self.assertEqual(("append_bytes",
708
("filename", "\na option 0 1 .b :"),
709
{}), transport.calls.pop(0))
710
self.assertTrue(index.has_version("a"))
711
self.assertEqual(1, index.num_versions())
712
self.assertEqual((None, 0, 1), index.get_position("a"))
713
self.assertEqual(["option"], index.get_options("a"))
714
self.assertEqual(("b",), index.get_parents_with_ghosts("a"))
715
716
index.add_version("a", ["opt"], (None, 1, 2), ["c"])
717
self.assertEqual(("append_bytes",
718
("filename", "\na opt 1 2 .c :"),
719
{}), transport.calls.pop(0))
720
self.assertTrue(index.has_version("a"))
721
self.assertEqual(1, index.num_versions())
722
self.assertEqual((None, 1, 2), index.get_position("a"))
723
self.assertEqual(["opt"], index.get_options("a"))
724
self.assertEqual(("c",), index.get_parents_with_ghosts("a"))
725
726
index.add_version("b", ["option"], (None, 2, 3), ["a"])
727
self.assertEqual(("append_bytes",
728
("filename", "\nb option 2 3 0 :"),
729
{}), transport.calls.pop(0))
730
self.assertTrue(index.has_version("b"))
731
self.assertEqual(2, index.num_versions())
732
self.assertEqual((None, 2, 3), index.get_position("b"))
733
self.assertEqual(["option"], index.get_options("b"))
734
self.assertEqual(("a",), index.get_parents_with_ghosts("b"))
662
735
663
736
def test_add_versions(self):
664
737
transport = MockTransport([
665
_KndxIndex.HEADER
738
_KnitIndex.HEADER
666
739
])
667
740
index = self.get_knit_index(transport, "filename", "r")
668
741
669
self.add_a_b(index)
670
call = transport.calls.pop(0)
671
# call[1][1] is a StringIO - we can't test it by simple equality.
672
self.assertEqual('put_file_non_atomic', call[0])
673
self.assertEqual('filename.kndx', call[1][0])
674
# With no history, _KndxIndex writes a new index:
675
self.assertEqual(
676
_KndxIndex.HEADER +
742
index.add_versions([
743
("a", ["option"], (None, 0, 1), ["b"]),
744
("a", ["opt"], (None, 1, 2), ["c"]),
745
("b", ["option"], (None, 2, 3), ["a"])
746
])
747
self.assertEqual(("append_bytes", ("filename",
677
748
"\na option 0 1 .b :"
678
749
"\na opt 1 2 .c :"
679
"\nb option 2 3 0 :",
680
call[1][1].getvalue())
681
self.assertEqual({'create_parent_dir': True}, call[2])
682
self.assertIndexIsAB(index)
750
"\nb option 2 3 0 :"
751
), {}), transport.calls.pop(0))
752
self.assertTrue(index.has_version("a"))
753
self.assertTrue(index.has_version("b"))
754
self.assertEqual(2, index.num_versions())
755
self.assertEqual((None, 1, 2), index.get_position("a"))
756
self.assertEqual((None, 2, 3), index.get_position("b"))
757
self.assertEqual(["opt"], index.get_options("a"))
758
self.assertEqual(["option"], index.get_options("b"))
759
self.assertEqual(("c",), index.get_parents_with_ghosts("a"))
760
self.assertEqual(("a",), index.get_parents_with_ghosts("b"))
683
761
684
762
def test_add_versions_random_id_is_accepted(self):
685
763
transport = MockTransport([
686
_KndxIndex.HEADER
764
_KnitIndex.HEADER
687
765
])
688
766
index = self.get_knit_index(transport, "filename", "r")
689
self.add_a_b(index, random_id=True)
767
768
index.add_versions([
769
("a", ["option"], (None, 0, 1), ["b"]),
770
("a", ["opt"], (None, 1, 2), ["c"]),
771
("b", ["option"], (None, 2, 3), ["a"])
772
], random_id=True)
690
773
691
774
def test_delay_create_and_add_versions(self):
692
775
transport = MockTransport()
693
776
694
index = self.get_knit_index(transport, "filename", "w")
695
# dir_mode=0777)
777
index = self.get_knit_index(transport, "filename", "w",
778
create=True, file_mode="wb", create_parent_dir=True,
779
delay_create=True, dir_mode=0777)
696
780
self.assertEqual([], transport.calls)
697
self.add_a_b(index)
698
#self.assertEqual(
699
#[ {"dir_mode": 0777, "create_parent_dir": True, "mode": "wb"},
700
# kwargs)
701
# Two calls: one during which we load the existing index (and when its
702
# missing create it), then a second where we write the contents out.
703
self.assertEqual(2, len(transport.calls))
704
call = transport.calls.pop(0)
705
self.assertEqual('put_file_non_atomic', call[0])
706
self.assertEqual('filename.kndx', call[1][0])
707
# With no history, _KndxIndex writes a new index:
708
self.assertEqual(_KndxIndex.HEADER, call[1][1].getvalue())
709
self.assertEqual({'create_parent_dir': True}, call[2])
710
call = transport.calls.pop(0)
711
# call[1][1] is a StringIO - we can't test it by simple equality.
712
self.assertEqual('put_file_non_atomic', call[0])
713
self.assertEqual('filename.kndx', call[1][0])
714
# With no history, _KndxIndex writes a new index:
715
self.assertEqual(
716
_KndxIndex.HEADER +
781
782
index.add_versions([
783
("a", ["option"], (None, 0, 1), ["b"]),
784
("a", ["opt"], (None, 1, 2), ["c"]),
785
("b", ["option"], (None, 2, 3), ["a"])
786
])
787
name, (filename, f), kwargs = transport.calls.pop(0)
788
self.assertEqual("put_file_non_atomic", name)
789
self.assertEqual(
790
{"dir_mode": 0777, "create_parent_dir": True, "mode": "wb"},
791
kwargs)
792
self.assertEqual("filename", filename)
793
self.assertEqual(
794
index.HEADER +
717
795
"\na option 0 1 .b :"
718
796
"\na opt 1 2 .c :"
719
797
"\nb option 2 3 0 :",
720
call[1][1].getvalue())
721
self.assertEqual({'create_parent_dir': True}, call[2])
798
f.read())
799
800
def test_has_version(self):
801
transport = MockTransport([
802
_KnitIndex.HEADER,
803
"a option 0 1 :"
804
])
805
index = self.get_knit_index(transport, "filename", "r")
806
807
self.assertTrue(index.has_version("a"))
808
self.assertFalse(index.has_version("b"))
722
809
723
810
def test_get_position(self):
724
811
transport = MockTransport([
725
_KndxIndex.HEADER,
812
_KnitIndex.HEADER,
726
813
"a option 0 1 :",
727
814
"b option 1 2 :"
728
815
])
729
816
index = self.get_knit_index(transport, "filename", "r")
730
817
731
self.assertEqual((("a",), 0, 1), index.get_position(("a",)))
732
self.assertEqual((("b",), 1, 2), index.get_position(("b",)))
818
self.assertEqual((None, 0, 1), index.get_position("a"))
819
self.assertEqual((None, 1, 2), index.get_position("b"))
733
820
734
821
def test_get_method(self):
735
822
transport = MockTransport([
736
_KndxIndex.HEADER,
823
_KnitIndex.HEADER,
737
824
"a fulltext,unknown 0 1 :",
738
825
"b unknown,line-delta 1 2 :",
739
826
"c bad 3 4 :"
746
833
747
834
def test_get_options(self):
748
835
transport = MockTransport([
749
_KndxIndex.HEADER,
836
_KnitIndex.HEADER,
750
837
"a opt1 0 1 :",
751
838
"b opt2,opt3 1 2 :"
752
839
])
757
844
758
845
def test_get_parent_map(self):
759
846
transport = MockTransport([
760
_KndxIndex.HEADER,
847
_KnitIndex.HEADER,
761
848
"a option 0 1 :",
762
849
"b option 1 2 0 .c :",
763
850
"c option 1 2 1 0 .e :"
765
852
index = self.get_knit_index(transport, "filename", "r")
766
853
767
854
self.assertEqual({
768
("a",):(),
769
("b",):(("a",), ("c",)),
770
("c",):(("b",), ("a",), ("e",)),
771
}, index.get_parent_map(index.keys()))
855
"a":(),
856
"b":("a", "c"),
857
"c":("b", "a", "e"),
858
}, index.get_parent_map(["a", "b", "c"]))
859
860
def test_get_parents_with_ghosts(self):
861
transport = MockTransport([
862
_KnitIndex.HEADER,
863
"a option 0 1 :",
864
"b option 1 2 0 .c :",
865
"c option 1 2 1 0 .e :"
866
])
867
index = self.get_knit_index(transport, "filename", "r")
868
869
self.assertEqual((), index.get_parents_with_ghosts("a"))
870
self.assertEqual(("a", "c"), index.get_parents_with_ghosts("b"))
871
self.assertEqual(("b", "a", "e"),
872
index.get_parents_with_ghosts("c"))
873
874
def test_check_versions_present(self):
875
transport = MockTransport([
876
_KnitIndex.HEADER,
877
"a option 0 1 :",
878
"b option 0 1 :"
879
])
880
index = self.get_knit_index(transport, "filename", "r")
881
882
check = index.check_versions_present
883
884
check([])
885
check(["a"])
886
check(["b"])
887
check(["a", "b"])
888
self.assertRaises(RevisionNotPresent, check, ["c"])
889
self.assertRaises(RevisionNotPresent, check, ["a", "b", "c"])
772
890
773
891
def test_impossible_parent(self):
774
892
"""Test we get KnitCorrupt if the parent couldn't possibly exist."""
775
893
transport = MockTransport([
776
_KndxIndex.HEADER,
894
_KnitIndex.HEADER,
777
895
"a option 0 1 :",
778
896
"b option 0 1 4 :" # We don't have a 4th record
779
897
])
780
index = self.get_knit_index(transport, 'filename', 'r')
781
898
try:
782
self.assertRaises(errors.KnitCorrupt, index.keys)
899
self.assertRaises(errors.KnitCorrupt,
900
self.get_knit_index, transport, 'filename', 'r')
783
901
except TypeError, e:
784
902
if (str(e) == ('exceptions must be strings, classes, or instances,'
785
903
' not exceptions.IndexError')
792
910
793
911
def test_corrupted_parent(self):
794
912
transport = MockTransport([
795
_KndxIndex.HEADER,
913
_KnitIndex.HEADER,
796
914
"a option 0 1 :",
797
915
"b option 0 1 :",
798
916
"c option 0 1 1v :", # Can't have a parent of '1v'
799
917
])
800
index = self.get_knit_index(transport, 'filename', 'r')
801
918
try:
802
self.assertRaises(errors.KnitCorrupt, index.keys)
919
self.assertRaises(errors.KnitCorrupt,
920
self.get_knit_index, transport, 'filename', 'r')
803
921
except TypeError, e:
804
922
if (str(e) == ('exceptions must be strings, classes, or instances,'
805
923
' not exceptions.ValueError')
812
930
813
931
def test_corrupted_parent_in_list(self):
814
932
transport = MockTransport([
815
_KndxIndex.HEADER,
933
_KnitIndex.HEADER,
816
934
"a option 0 1 :",
817
935
"b option 0 1 :",
818
936
"c option 0 1 1 v :", # Can't have a parent of 'v'
819
937
])
820
index = self.get_knit_index(transport, 'filename', 'r')
821
938
try:
822
self.assertRaises(errors.KnitCorrupt, index.keys)
939
self.assertRaises(errors.KnitCorrupt,
940
self.get_knit_index, transport, 'filename', 'r')
823
941
except TypeError, e:
824
942
if (str(e) == ('exceptions must be strings, classes, or instances,'
825
943
' not exceptions.ValueError')
832
950
833
951
def test_invalid_position(self):
834
952
transport = MockTransport([
835
_KndxIndex.HEADER,
953
_KnitIndex.HEADER,
836
954
"a option 1v 1 :",
837
955
])
838
index = self.get_knit_index(transport, 'filename', 'r')
839
956
try:
840
self.assertRaises(errors.KnitCorrupt, index.keys)
957
self.assertRaises(errors.KnitCorrupt,
958
self.get_knit_index, transport, 'filename', 'r')
841
959
except TypeError, e:
842
960
if (str(e) == ('exceptions must be strings, classes, or instances,'
843
961
' not exceptions.ValueError')
850
968
851
969
def test_invalid_size(self):
852
970
transport = MockTransport([
853
_KndxIndex.HEADER,
971
_KnitIndex.HEADER,
854
972
"a option 1 1v :",
855
973
])
856
index = self.get_knit_index(transport, 'filename', 'r')
857
974
try:
858
self.assertRaises(errors.KnitCorrupt, index.keys)
975
self.assertRaises(errors.KnitCorrupt,
976
self.get_knit_index, transport, 'filename', 'r')
859
977
except TypeError, e:
860
978
if (str(e) == ('exceptions must be strings, classes, or instances,'
861
979
' not exceptions.ValueError')
868
986
869
987
def test_short_line(self):
870
988
transport = MockTransport([
871
_KndxIndex.HEADER,
989
_KnitIndex.HEADER,
872
990
"a option 0 10 :",
873
991
"b option 10 10 0", # This line isn't terminated, ignored
874
992
])
875
993
index = self.get_knit_index(transport, "filename", "r")
876
self.assertEqual(set([('a',)]), index.keys())
994
self.assertEqual(['a'], index.get_versions())
877
995
878
996
def test_skip_incomplete_record(self):
879
997
# A line with bogus data should just be skipped
880
998
transport = MockTransport([
881
_KndxIndex.HEADER,
999
_KnitIndex.HEADER,
882
1000
"a option 0 10 :",
883
1001
"b option 10 10 0", # This line isn't terminated, ignored
884
1002
"c option 20 10 0 :", # Properly terminated, and starts with '\n'
885
1003
])
886
1004
index = self.get_knit_index(transport, "filename", "r")
887
self.assertEqual(set([('a',), ('c',)]), index.keys())
1005
self.assertEqual(['a', 'c'], index.get_versions())
888
1006
889
1007
def test_trailing_characters(self):
890
1008
# A line with bogus data should just be skipped
891
1009
transport = MockTransport([
892
_KndxIndex.HEADER,
1010
_KnitIndex.HEADER,
893
1011
"a option 0 10 :",
894
1012
"b option 10 10 0 :a", # This line has extra trailing characters
895
1013
"c option 20 10 0 :", # Properly terminated, and starts with '\n'
896
1014
])
897
1015
index = self.get_knit_index(transport, "filename", "r")
898
self.assertEqual(set([('a',), ('c',)]), index.keys())
1016
self.assertEqual(['a', 'c'], index.get_versions())
899
1017
900
1018
901
1019
class LowLevelKnitIndexTests_c(LowLevelKnitIndexTests):
902
1020
903
1021
_test_needs_features = [CompiledKnitFeature]
904
1022
905
def get_knit_index(self, transport, name, mode):
906
mapper = ConstantMapper(name)
1023
def get_knit_index(self, *args, **kwargs):
907
1024
orig = knit._load_data
908
1025
def reset():
909
1026
knit._load_data = orig
910
1027
self.addCleanup(reset)
911
1028
from bzrlib._knit_load_data_c import _load_data_c
912
1029
knit._load_data = _load_data_c
913
allow_writes = lambda: mode == 'w'
914
return _KndxIndex(transport, mapper, lambda:None, allow_writes, lambda:True)
1030
return _KnitIndex(get_scope=lambda:None, *args, **kwargs)
915
1031
916
1032
917
1033
class KnitTests(TestCaseWithTransport):
918
1034
"""Class containing knit test helper routines."""
919
1035
920
def make_test_knit(self, annotate=False, name='test'):
921
mapper = ConstantMapper(name)
922
return make_file_factory(annotate, mapper)(self.get_transport())
1036
def make_test_knit(self, annotate=False, delay_create=False, index=None,
1037
name='test', delta=True, access_mode='w'):
1038
if not annotate:
1039
factory = KnitPlainFactory()
1040
else:
1041
factory = None
1042
if index is None:
1043
index = _KnitIndex(get_transport('.'), name + INDEX_SUFFIX,
1044
access_mode, create=True, file_mode=None,
1045
create_parent_dir=False, delay_create=delay_create,
1046
dir_mode=None, get_scope=lambda:None)
1047
access = _KnitAccess(get_transport('.'), name + DATA_SUFFIX, None,
1048
None, delay_create, False)
1049
return KnitVersionedFile(name, get_transport('.'), factory=factory,
1050
create=True, delay_create=delay_create, index=index,
1051
access_method=access, delta=delta)
1052
1053
def assertRecordContentEqual(self, knit, version_id, candidate_content):
1054
"""Assert that some raw record content matches the raw record content
1055
for a particular version_id in the given knit.
1056
"""
1057
index_memo = knit._index.get_position(version_id)
1058
record = (version_id, index_memo)
1059
[(_, expected_content)] = list(knit._data.read_records_iter_raw([record]))
1060
self.assertEqual(expected_content, candidate_content)
1061
1062
1063
class BasicKnitTests(KnitTests):
1064
1065
def add_stock_one_and_one_a(self, k):
1066
k.add_lines('text-1', [], split_lines(TEXT_1))
1067
k.add_lines('text-1a', ['text-1'], split_lines(TEXT_1A))
1068
1069
def test_knit_constructor(self):
1070
"""Construct empty k"""
1071
self.make_test_knit()
1072
1073
def test_make_explicit_index(self):
1074
"""We can supply an index to use."""
1075
knit = KnitVersionedFile('test', get_transport('.'),
1076
index='strangelove', access_method="a")
1077
self.assertEqual(knit._index, 'strangelove')
1078
1079
def test_knit_add(self):
1080
"""Store one text in knit and retrieve"""
1081
k = self.make_test_knit()
1082
k.add_lines('text-1', [], split_lines(TEXT_1))
1083
self.assertTrue(k.has_version('text-1'))
1084
self.assertEqualDiff(''.join(k.get_lines('text-1')), TEXT_1)
1085
1086
def test_newline_empty_lines(self):
1087
# ensure that ["\n"] round trips ok.
1088
knit = self.make_test_knit()
1089
knit.add_lines('a', [], ["\n"])
1090
knit.add_lines_with_ghosts('b', [], ["\n"])
1091
self.assertEqual(["\n"], knit.get_lines('a'))
1092
self.assertEqual(["\n"], knit.get_lines('b'))
1093
self.assertEqual(['fulltext'], knit._index.get_options('a'))
1094
self.assertEqual(['fulltext'], knit._index.get_options('b'))
1095
knit.add_lines('c', ['a'], ["\n"])
1096
knit.add_lines_with_ghosts('d', ['b'], ["\n"])
1097
self.assertEqual(["\n"], knit.get_lines('c'))
1098
self.assertEqual(["\n"], knit.get_lines('d'))
1099
self.assertEqual(['line-delta'], knit._index.get_options('c'))
1100
self.assertEqual(['line-delta'], knit._index.get_options('d'))
1101
1102
def test_empty_lines(self):
1103
# bizarrely, [] is not listed as having no-eol.
1104
knit = self.make_test_knit()
1105
knit.add_lines('a', [], [])
1106
knit.add_lines_with_ghosts('b', [], [])
1107
self.assertEqual([], knit.get_lines('a'))
1108
self.assertEqual([], knit.get_lines('b'))
1109
self.assertEqual(['fulltext'], knit._index.get_options('a'))
1110
self.assertEqual(['fulltext'], knit._index.get_options('b'))
1111
knit.add_lines('c', ['a'], [])
1112
knit.add_lines_with_ghosts('d', ['b'], [])
1113
self.assertEqual([], knit.get_lines('c'))
1114
self.assertEqual([], knit.get_lines('d'))
1115
self.assertEqual(['line-delta'], knit._index.get_options('c'))
1116
self.assertEqual(['line-delta'], knit._index.get_options('d'))
1117
1118
def test_knit_reload(self):
1119
# test that the content in a reloaded knit is correct
1120
k = self.make_test_knit()
1121
k.add_lines('text-1', [], split_lines(TEXT_1))
1122
del k
1123
k2 = make_file_knit('test', get_transport('.'), access_mode='r',
1124
factory=KnitPlainFactory(), create=True)
1125
self.assertTrue(k2.has_version('text-1'))
1126
self.assertEqualDiff(''.join(k2.get_lines('text-1')), TEXT_1)
1127
1128
def test_knit_several(self):
1129
"""Store several texts in a knit"""
1130
k = self.make_test_knit()
1131
k.add_lines('text-1', [], split_lines(TEXT_1))
1132
k.add_lines('text-2', [], split_lines(TEXT_2))
1133
self.assertEqualDiff(''.join(k.get_lines('text-1')), TEXT_1)
1134
self.assertEqualDiff(''.join(k.get_lines('text-2')), TEXT_2)
1135
1136
def test_repeated_add(self):
1137
"""Knit traps attempt to replace existing version"""
1138
k = self.make_test_knit()
1139
k.add_lines('text-1', [], split_lines(TEXT_1))
1140
self.assertRaises(RevisionAlreadyPresent,
1141
k.add_lines,
1142
'text-1', [], split_lines(TEXT_1))
1143
1144
def test_empty(self):
1145
k = self.make_test_knit(True)
1146
k.add_lines('text-1', [], [])
1147
self.assertEquals(k.get_lines('text-1'), [])
1148
1149
def test_incomplete(self):
1150
"""Test if texts without a ending line-end can be inserted and
1151
extracted."""
1152
k = make_file_knit('test', get_transport('.'), delta=False, create=True)
1153
k.add_lines('text-1', [], ['a\n', 'b' ])
1154
k.add_lines('text-2', ['text-1'], ['a\rb\n', 'b\n'])
1155
# reopening ensures maximum room for confusion
1156
k = make_file_knit('test', get_transport('.'), delta=False, create=True)
1157
self.assertEquals(k.get_lines('text-1'), ['a\n', 'b' ])
1158
self.assertEquals(k.get_lines('text-2'), ['a\rb\n', 'b\n'])
1159
1160
def test_delta(self):
1161
"""Expression of knit delta as lines"""
1162
k = self.make_test_knit()
1163
td = list(line_delta(TEXT_1.splitlines(True),
1164
TEXT_1A.splitlines(True)))
1165
self.assertEqualDiff(''.join(td), delta_1_1a)
1166
out = apply_line_delta(TEXT_1.splitlines(True), td)
1167
self.assertEqualDiff(''.join(out), TEXT_1A)
1168
1169
def test_add_with_parents(self):
1170
"""Store in knit with parents"""
1171
k = self.make_test_knit()
1172
self.add_stock_one_and_one_a(k)
1173
self.assertEqual({'text-1':(), 'text-1a':('text-1',)},
1174
k.get_parent_map(['text-1', 'text-1a']))
1175
1176
def test_ancestry(self):
1177
"""Store in knit with parents"""
1178
k = self.make_test_knit()
1179
self.add_stock_one_and_one_a(k)
1180
self.assertEquals(set(k.get_ancestry(['text-1a'])), set(['text-1a', 'text-1']))
1181
1182
def test_add_delta(self):
1183
"""Store in knit with parents"""
1184
k = self.make_test_knit(annotate=False)
1185
self.add_stock_one_and_one_a(k)
1186
self.assertEqualDiff(''.join(k.get_lines('text-1a')), TEXT_1A)
1187
1188
def test_add_delta_knit_graph_index(self):
1189
"""Does adding work with a KnitGraphIndex."""
1190
index = InMemoryGraphIndex(2)
1191
knit_index = KnitGraphIndex(index, add_callback=index.add_nodes,
1192
deltas=True)
1193
k = self.make_test_knit(annotate=True, index=knit_index)
1194
self.add_stock_one_and_one_a(k)
1195
self.assertEqualDiff(''.join(k.get_lines('text-1a')), TEXT_1A)
1196
# check the index had the right data added.
1197
self.assertEqual(set([
1198
(index, ('text-1', ), ' 0 127', ((), ())),
1199
(index, ('text-1a', ), ' 127 140', ((('text-1', ),), (('text-1', ),))),
1200
]), set(index.iter_all_entries()))
1201
# we should not have a .kndx file
1202
self.assertFalse(get_transport('.').has('test.kndx'))
1203
1204
def test_annotate(self):
1205
"""Annotations"""
1206
k = self.make_test_knit(annotate=True, name='knit')
1207
self.insert_and_test_small_annotate(k)
1208
1209
def insert_and_test_small_annotate(self, k):
1210
"""test annotation with k works correctly."""
1211
k.add_lines('text-1', [], ['a\n', 'b\n'])
1212
k.add_lines('text-2', ['text-1'], ['a\n', 'c\n'])
1213
1214
origins = k.annotate('text-2')
1215
self.assertEquals(origins[0], ('text-1', 'a\n'))
1216
self.assertEquals(origins[1], ('text-2', 'c\n'))
1217
1218
def test_annotate_fulltext(self):
1219
"""Annotations"""
1220
k = self.make_test_knit(annotate=True, name='knit', delta=False)
1221
self.insert_and_test_small_annotate(k)
1222
1223
def test_annotate_merge_1(self):
1224
k = self.make_test_knit(True)
1225
k.add_lines('text-a1', [], ['a\n', 'b\n'])
1226
k.add_lines('text-a2', [], ['d\n', 'c\n'])
1227
k.add_lines('text-am', ['text-a1', 'text-a2'], ['d\n', 'b\n'])
1228
origins = k.annotate('text-am')
1229
self.assertEquals(origins[0], ('text-a2', 'd\n'))
1230
self.assertEquals(origins[1], ('text-a1', 'b\n'))
1231
1232
def test_annotate_merge_2(self):
1233
k = self.make_test_knit(True)
1234
k.add_lines('text-a1', [], ['a\n', 'b\n', 'c\n'])
1235
k.add_lines('text-a2', [], ['x\n', 'y\n', 'z\n'])
1236
k.add_lines('text-am', ['text-a1', 'text-a2'], ['a\n', 'y\n', 'c\n'])
1237
origins = k.annotate('text-am')
1238
self.assertEquals(origins[0], ('text-a1', 'a\n'))
1239
self.assertEquals(origins[1], ('text-a2', 'y\n'))
1240
self.assertEquals(origins[2], ('text-a1', 'c\n'))
1241
1242
def test_annotate_merge_9(self):
1243
k = self.make_test_knit(True)
1244
k.add_lines('text-a1', [], ['a\n', 'b\n', 'c\n'])
1245
k.add_lines('text-a2', [], ['x\n', 'y\n', 'z\n'])
1246
k.add_lines('text-am', ['text-a1', 'text-a2'], ['k\n', 'y\n', 'c\n'])
1247
origins = k.annotate('text-am')
1248
self.assertEquals(origins[0], ('text-am', 'k\n'))
1249
self.assertEquals(origins[1], ('text-a2', 'y\n'))
1250
self.assertEquals(origins[2], ('text-a1', 'c\n'))
1251
1252
def test_annotate_merge_3(self):
1253
k = self.make_test_knit(True)
1254
k.add_lines('text-a1', [], ['a\n', 'b\n', 'c\n'])
1255
k.add_lines('text-a2', [] ,['x\n', 'y\n', 'z\n'])
1256
k.add_lines('text-am', ['text-a1', 'text-a2'], ['k\n', 'y\n', 'z\n'])
1257
origins = k.annotate('text-am')
1258
self.assertEquals(origins[0], ('text-am', 'k\n'))
1259
self.assertEquals(origins[1], ('text-a2', 'y\n'))
1260
self.assertEquals(origins[2], ('text-a2', 'z\n'))
1261
1262
def test_annotate_merge_4(self):
1263
k = self.make_test_knit(True)
1264
k.add_lines('text-a1', [], ['a\n', 'b\n', 'c\n'])
1265
k.add_lines('text-a2', [], ['x\n', 'y\n', 'z\n'])
1266
k.add_lines('text-a3', ['text-a1'], ['a\n', 'b\n', 'p\n'])
1267
k.add_lines('text-am', ['text-a2', 'text-a3'], ['a\n', 'b\n', 'z\n'])
1268
origins = k.annotate('text-am')
1269
self.assertEquals(origins[0], ('text-a1', 'a\n'))
1270
self.assertEquals(origins[1], ('text-a1', 'b\n'))
1271
self.assertEquals(origins[2], ('text-a2', 'z\n'))
1272
1273
def test_annotate_merge_5(self):
1274
k = self.make_test_knit(True)
1275
k.add_lines('text-a1', [], ['a\n', 'b\n', 'c\n'])
1276
k.add_lines('text-a2', [], ['d\n', 'e\n', 'f\n'])
1277
k.add_lines('text-a3', [], ['x\n', 'y\n', 'z\n'])
1278
k.add_lines('text-am',
1279
['text-a1', 'text-a2', 'text-a3'],
1280
['a\n', 'e\n', 'z\n'])
1281
origins = k.annotate('text-am')
1282
self.assertEquals(origins[0], ('text-a1', 'a\n'))
1283
self.assertEquals(origins[1], ('text-a2', 'e\n'))
1284
self.assertEquals(origins[2], ('text-a3', 'z\n'))
1285
1286
def test_annotate_file_cherry_pick(self):
1287
k = self.make_test_knit(True)
1288
k.add_lines('text-1', [], ['a\n', 'b\n', 'c\n'])
1289
k.add_lines('text-2', ['text-1'], ['d\n', 'e\n', 'f\n'])
1290
k.add_lines('text-3', ['text-2', 'text-1'], ['a\n', 'b\n', 'c\n'])
1291
origins = k.annotate('text-3')
1292
self.assertEquals(origins[0], ('text-1', 'a\n'))
1293
self.assertEquals(origins[1], ('text-1', 'b\n'))
1294
self.assertEquals(origins[2], ('text-1', 'c\n'))
1295
1296
def _test_join_with_factories(self, k1_factory, k2_factory):
1297
k1 = make_file_knit('test1', get_transport('.'), factory=k1_factory, create=True)
1298
k1.add_lines('text-a', [], ['a1\n', 'a2\n', 'a3\n'])
1299
k1.add_lines('text-b', ['text-a'], ['a1\n', 'b2\n', 'a3\n'])
1300
k1.add_lines('text-c', [], ['c1\n', 'c2\n', 'c3\n'])
1301
k1.add_lines('text-d', ['text-c'], ['c1\n', 'd2\n', 'd3\n'])
1302
k1.add_lines('text-m', ['text-b', 'text-d'], ['a1\n', 'b2\n', 'd3\n'])
1303
k2 = make_file_knit('test2', get_transport('.'), factory=k2_factory, create=True)
1304
count = k2.join(k1, version_ids=['text-m'])
1305
self.assertEquals(count, 5)
1306
self.assertTrue(k2.has_version('text-a'))
1307
self.assertTrue(k2.has_version('text-c'))
1308
origins = k2.annotate('text-m')
1309
self.assertEquals(origins[0], ('text-a', 'a1\n'))
1310
self.assertEquals(origins[1], ('text-b', 'b2\n'))
1311
self.assertEquals(origins[2], ('text-d', 'd3\n'))
1312
1313
def test_knit_join_plain_to_plain(self):
1314
"""Test joining a plain knit with a plain knit."""
1315
self._test_join_with_factories(KnitPlainFactory(), KnitPlainFactory())
1316
1317
def test_knit_join_anno_to_anno(self):
1318
"""Test joining an annotated knit with an annotated knit."""
1319
self._test_join_with_factories(None, None)
1320
1321
def test_knit_join_anno_to_plain(self):
1322
"""Test joining an annotated knit with a plain knit."""
1323
self._test_join_with_factories(None, KnitPlainFactory())
1324
1325
def test_knit_join_plain_to_anno(self):
1326
"""Test joining a plain knit with an annotated knit."""
1327
self._test_join_with_factories(KnitPlainFactory(), None)
1328
1329
def test_reannotate(self):
1330
k1 = make_file_knit('knit1', get_transport('.'),
1331
factory=KnitAnnotateFactory(), create=True)
1332
# 0
1333
k1.add_lines('text-a', [], ['a\n', 'b\n'])
1334
# 1
1335
k1.add_lines('text-b', ['text-a'], ['a\n', 'c\n'])
1336
1337
k2 = make_file_knit('test2', get_transport('.'),
1338
factory=KnitAnnotateFactory(), create=True)
1339
k2.join(k1, version_ids=['text-b'])
1340
1341
# 2
1342
k1.add_lines('text-X', ['text-b'], ['a\n', 'b\n'])
1343
# 2
1344
k2.add_lines('text-c', ['text-b'], ['z\n', 'c\n'])
1345
# 3
1346
k2.add_lines('text-Y', ['text-b'], ['b\n', 'c\n'])
1347
1348
# test-c will have index 3
1349
k1.join(k2, version_ids=['text-c'])
1350
1351
lines = k1.get_lines('text-c')
1352
self.assertEquals(lines, ['z\n', 'c\n'])
1353
1354
origins = k1.annotate('text-c')
1355
self.assertEquals(origins[0], ('text-c', 'z\n'))
1356
self.assertEquals(origins[1], ('text-b', 'c\n'))
1357
1358
def test_get_line_delta_texts(self):
1359
"""Make sure we can call get_texts on text with reused line deltas"""
1360
k1 = make_file_knit('test1', get_transport('.'),
1361
factory=KnitPlainFactory(), create=True)
1362
for t in range(3):
1363
if t == 0:
1364
parents = []
1365
else:
1366
parents = ['%d' % (t-1)]
1367
k1.add_lines('%d' % t, parents, ['hello\n'] * t)
1368
k1.get_texts(('%d' % t) for t in range(3))
1369
1370
def test_iter_lines_reads_in_order(self):
1371
instrumented_t = get_transport('trace+memory:///')
1372
k1 = make_file_knit('id', instrumented_t, create=True, delta=True)
1373
self.assertEqual([('get', 'id.kndx',)], instrumented_t._activity)
1374
# add texts with no required ordering
1375
k1.add_lines('base', [], ['text\n'])
1376
k1.add_lines('base2', [], ['text2\n'])
1377
# clear the logged activity, but preserve the list instance in case of
1378
# clones pointing at it.
1379
del instrumented_t._activity[:]
1380
# request a last-first iteration
1381
results = list(k1.iter_lines_added_or_present_in_versions(
1382
['base2', 'base']))
1383
self.assertEqual(
1384
[('readv', 'id.knit', [(0, 87), (87, 89)], False, None)],
1385
instrumented_t._activity)
1386
self.assertEqual([('text\n', 'base'), ('text2\n', 'base2')], results)
1387
1388
def test_knit_format(self):
1389
# this tests that a new knit index file has the expected content
1390
# and that is writes the data we expect as records are added.
1391
knit = self.make_test_knit(True)
1392
# Now knit files are not created until we first add data to them
1393
self.assertFileEqual("# bzr knit index 8\n", 'test.kndx')
1394
knit.add_lines_with_ghosts('revid', ['a_ghost'], ['a\n'])
1395
self.assertFileEqual(
1396
"# bzr knit index 8\n"
1397
"\n"
1398
"revid fulltext 0 84 .a_ghost :",
1399
'test.kndx')
1400
knit.add_lines_with_ghosts('revid2', ['revid'], ['a\n'])
1401
self.assertFileEqual(
1402
"# bzr knit index 8\n"
1403
"\nrevid fulltext 0 84 .a_ghost :"
1404
"\nrevid2 line-delta 84 82 0 :",
1405
'test.kndx')
1406
# we should be able to load this file again
1407
knit = make_file_knit('test', get_transport('.'), access_mode='r')
1408
self.assertEqual(['revid', 'revid2'], knit.versions())
1409
# write a short write to the file and ensure that its ignored
1410
indexfile = file('test.kndx', 'ab')
1411
indexfile.write('\nrevid3 line-delta 166 82 1 2 3 4 5 .phwoar:demo ')
1412
indexfile.close()
1413
# we should be able to load this file again
1414
knit = make_file_knit('test', get_transport('.'), access_mode='w')
1415
self.assertEqual(['revid', 'revid2'], knit.versions())
1416
# and add a revision with the same id the failed write had
1417
knit.add_lines('revid3', ['revid2'], ['a\n'])
1418
# and when reading it revid3 should now appear.
1419
knit = make_file_knit('test', get_transport('.'), access_mode='r')
1420
self.assertEqual(['revid', 'revid2', 'revid3'], knit.versions())
1421
self.assertEqual({'revid3':('revid2',)}, knit.get_parent_map(['revid3']))
1422
1423
def test_delay_create(self):
1424
"""Test that passing delay_create=True creates files late"""
1425
knit = self.make_test_knit(annotate=True, delay_create=True)
1426
self.failIfExists('test.knit')
1427
self.failIfExists('test.kndx')
1428
knit.add_lines_with_ghosts('revid', ['a_ghost'], ['a\n'])
1429
self.failUnlessExists('test.knit')
1430
self.assertFileEqual(
1431
"# bzr knit index 8\n"
1432
"\n"
1433
"revid fulltext 0 84 .a_ghost :",
1434
'test.kndx')
1435
1436
def test_create_parent_dir(self):
1437
"""create_parent_dir can create knits in nonexistant dirs"""
1438
# Has no effect if we don't set 'delay_create'
1439
trans = get_transport('.')
1440
self.assertRaises(NoSuchFile, make_file_knit, 'dir/test',
1441
trans, access_mode='w', factory=None,
1442
create=True, create_parent_dir=True)
1443
# Nothing should have changed yet
1444
knit = make_file_knit('dir/test', trans, access_mode='w',
1445
factory=None, create=True,
1446
create_parent_dir=True,
1447
delay_create=True)
1448
self.failIfExists('dir/test.knit')
1449
self.failIfExists('dir/test.kndx')
1450
self.failIfExists('dir')
1451
knit.add_lines('revid', [], ['a\n'])
1452
self.failUnlessExists('dir')
1453
self.failUnlessExists('dir/test.knit')
1454
self.assertFileEqual(
1455
"# bzr knit index 8\n"
1456
"\n"
1457
"revid fulltext 0 84 :",
1458
'dir/test.kndx')
1459
1460
def test_create_mode_700(self):
1461
trans = get_transport('.')
1462
if not trans._can_roundtrip_unix_modebits():
1463
# Can't roundtrip, so no need to run this test
1464
return
1465
knit = make_file_knit('dir/test', trans, access_mode='w', factory=None,
1466
create=True, create_parent_dir=True, delay_create=True,
1467
file_mode=0600, dir_mode=0700)
1468
knit.add_lines('revid', [], ['a\n'])
1469
self.assertTransportMode(trans, 'dir', 0700)
1470
self.assertTransportMode(trans, 'dir/test.knit', 0600)
1471
self.assertTransportMode(trans, 'dir/test.kndx', 0600)
1472
1473
def test_create_mode_770(self):
1474
trans = get_transport('.')
1475
if not trans._can_roundtrip_unix_modebits():
1476
# Can't roundtrip, so no need to run this test
1477
return
1478
knit = make_file_knit('dir/test', trans, access_mode='w', factory=None,
1479
create=True, create_parent_dir=True, delay_create=True,
1480
file_mode=0660, dir_mode=0770)
1481
knit.add_lines('revid', [], ['a\n'])
1482
self.assertTransportMode(trans, 'dir', 0770)
1483
self.assertTransportMode(trans, 'dir/test.knit', 0660)
1484
self.assertTransportMode(trans, 'dir/test.kndx', 0660)
1485
1486
def test_create_mode_777(self):
1487
trans = get_transport('.')
1488
if not trans._can_roundtrip_unix_modebits():
1489
# Can't roundtrip, so no need to run this test
1490
return
1491
knit = make_file_knit('dir/test', trans, access_mode='w', factory=None,
1492
create=True, create_parent_dir=True, delay_create=True,
1493
file_mode=0666, dir_mode=0777)
1494
knit.add_lines('revid', [], ['a\n'])
1495
self.assertTransportMode(trans, 'dir', 0777)
1496
self.assertTransportMode(trans, 'dir/test.knit', 0666)
1497
self.assertTransportMode(trans, 'dir/test.kndx', 0666)
1498
1499
def test_plan_merge(self):
1500
my_knit = self.make_test_knit(annotate=True)
1501
my_knit.add_lines('text1', [], split_lines(TEXT_1))
1502
my_knit.add_lines('text1a', ['text1'], split_lines(TEXT_1A))
1503
my_knit.add_lines('text1b', ['text1'], split_lines(TEXT_1B))
1504
plan = list(my_knit.plan_merge('text1a', 'text1b'))
1505
for plan_line, expected_line in zip(plan, AB_MERGE):
1506
self.assertEqual(plan_line, expected_line)
1507
1508
def test_get_stream_empty(self):
1509
"""Get a data stream for an empty knit file."""
1510
k1 = self.make_test_knit()
1511
format, data_list, reader_callable = k1.get_data_stream([])
1512
self.assertEqual('knit-plain', format)
1513
self.assertEqual([], data_list)
1514
content = reader_callable(None)
1515
self.assertEqual('', content)
1516
self.assertIsInstance(content, str)
1517
1518
def test_get_stream_one_version(self):
1519
"""Get a data stream for a single record out of a knit containing just
1520
one record.
1521
"""
1522
k1 = self.make_test_knit()
1523
test_data = [
1524
('text-a', [], TEXT_1),
1525
]
1526
expected_data_list = [
1527
# version, options, length, parents
1528
('text-a', ['fulltext'], 122, ()),
1529
]
1530
for version_id, parents, lines in test_data:
1531
k1.add_lines(version_id, parents, split_lines(lines))
1532
1533
format, data_list, reader_callable = k1.get_data_stream(['text-a'])
1534
self.assertEqual('knit-plain', format)
1535
self.assertEqual(expected_data_list, data_list)
1536
# There's only one record in the knit, so the content should be the
1537
# entire knit data file's contents.
1538
self.assertEqual(k1.transport.get_bytes(k1._data._access._filename),
1539
reader_callable(None))
1540
1541
def test_get_stream_get_one_version_of_many(self):
1542
"""Get a data stream for just one version out of a knit containing many
1543
versions.
1544
"""
1545
k1 = self.make_test_knit()
1546
# Insert the same data as test_knit_join, as they seem to cover a range
1547
# of cases (no parents, one parent, multiple parents).
1548
test_data = [
1549
('text-a', [], TEXT_1),
1550
('text-b', ['text-a'], TEXT_1),
1551
('text-c', [], TEXT_1),
1552
('text-d', ['text-c'], TEXT_1),
1553
('text-m', ['text-b', 'text-d'], TEXT_1),
1554
]
1555
expected_data_list = [
1556
# version, options, length, parents
1557
('text-m', ['line-delta'], 84, ('text-b', 'text-d')),
1558
]
1559
for version_id, parents, lines in test_data:
1560
k1.add_lines(version_id, parents, split_lines(lines))
1561
1562
format, data_list, reader_callable = k1.get_data_stream(['text-m'])
1563
self.assertEqual('knit-plain', format)
1564
self.assertEqual(expected_data_list, data_list)
1565
self.assertRecordContentEqual(k1, 'text-m', reader_callable(None))
1566
1567
def test_get_data_stream_unordered_index(self):
1568
"""Get a data stream when the knit index reports versions out of order.
1569
1570
https://bugs.launchpad.net/bzr/+bug/164637
1571
"""
1572
k1 = self.make_test_knit()
1573
test_data = [
1574
('text-a', [], TEXT_1),
1575
('text-b', ['text-a'], TEXT_1),
1576
('text-c', [], TEXT_1),
1577
('text-d', ['text-c'], TEXT_1),
1578
('text-m', ['text-b', 'text-d'], TEXT_1),
1579
]
1580
for version_id, parents, lines in test_data:
1581
k1.add_lines(version_id, parents, split_lines(lines))
1582
# monkey-patch versions method to return out of order, as if coming
1583
# from multiple independently indexed packs
1584
original_versions = k1.versions
1585
k1.versions = lambda: reversed(original_versions())
1586
expected_data_list = [
1587
('text-a', ['fulltext'], 122, ()),
1588
('text-b', ['line-delta'], 84, ('text-a',))]
1589
# now check the fulltext is first and the delta second
1590
format, data_list, _ = k1.get_data_stream(['text-a', 'text-b'])
1591
self.assertEqual('knit-plain', format)
1592
self.assertEqual(expected_data_list, data_list)
1593
# and that's true if we ask for them in the opposite order too
1594
format, data_list, _ = k1.get_data_stream(['text-b', 'text-a'])
1595
self.assertEqual(expected_data_list, data_list)
1596
# also try requesting more versions
1597
format, data_list, _ = k1.get_data_stream([
1598
'text-m', 'text-b', 'text-a'])
1599
self.assertEqual([
1600
('text-a', ['fulltext'], 122, ()),
1601
('text-b', ['line-delta'], 84, ('text-a',)),
1602
('text-m', ['line-delta'], 84, ('text-b', 'text-d')),
1603
], data_list)
1604
1605
def test_get_stream_ghost_parent(self):
1606
"""Get a data stream for a version with a ghost parent."""
1607
k1 = self.make_test_knit()
1608
# Test data
1609
k1.add_lines('text-a', [], split_lines(TEXT_1))
1610
k1.add_lines_with_ghosts('text-b', ['text-a', 'text-ghost'],
1611
split_lines(TEXT_1))
1612
# Expected data
1613
expected_data_list = [
1614
# version, options, length, parents
1615
('text-b', ['line-delta'], 84, ('text-a', 'text-ghost')),
1616
]
1617
1618
format, data_list, reader_callable = k1.get_data_stream(['text-b'])
1619
self.assertEqual('knit-plain', format)
1620
self.assertEqual(expected_data_list, data_list)
1621
self.assertRecordContentEqual(k1, 'text-b', reader_callable(None))
1622
1623
def test_get_stream_get_multiple_records(self):
1624
"""Get a stream for multiple records of a knit."""
1625
k1 = self.make_test_knit()
1626
# Insert the same data as test_knit_join, as they seem to cover a range
1627
# of cases (no parents, one parent, multiple parents).
1628
test_data = [
1629
('text-a', [], TEXT_1),
1630
('text-b', ['text-a'], TEXT_1),
1631
('text-c', [], TEXT_1),
1632
('text-d', ['text-c'], TEXT_1),
1633
('text-m', ['text-b', 'text-d'], TEXT_1),
1634
]
1635
for version_id, parents, lines in test_data:
1636
k1.add_lines(version_id, parents, split_lines(lines))
1637
1638
# This test is actually a bit strict as the order in which they're
1639
# returned is not defined. This matches the current (deterministic)
1640
# behaviour.
1641
expected_data_list = [
1642
# version, options, length, parents
1643
('text-d', ['line-delta'], 84, ('text-c',)),
1644
('text-b', ['line-delta'], 84, ('text-a',)),
1645
]
1646
# Note that even though we request the revision IDs in a particular
1647
# order, the data stream may return them in any order it likes. In this
1648
# case, they'll be in the order they were inserted into the knit.
1649
format, data_list, reader_callable = k1.get_data_stream(
1650
['text-d', 'text-b'])
1651
self.assertEqual('knit-plain', format)
1652
self.assertEqual(expected_data_list, data_list)
1653
# must match order they're returned
1654
self.assertRecordContentEqual(k1, 'text-d', reader_callable(84))
1655
self.assertRecordContentEqual(k1, 'text-b', reader_callable(84))
1656
self.assertEqual('', reader_callable(None),
1657
"There should be no more bytes left to read.")
1658
1659
def test_get_stream_all(self):
1660
"""Get a data stream for all the records in a knit.
1661
1662
This exercises fulltext records, line-delta records, records with
1663
various numbers of parents, and reading multiple records out of the
1664
callable. These cases ought to all be exercised individually by the
1665
other test_get_stream_* tests; this test is basically just paranoia.
1666
"""
1667
k1 = self.make_test_knit()
1668
# Insert the same data as test_knit_join, as they seem to cover a range
1669
# of cases (no parents, one parent, multiple parents).
1670
test_data = [
1671
('text-a', [], TEXT_1),
1672
('text-b', ['text-a'], TEXT_1),
1673
('text-c', [], TEXT_1),
1674
('text-d', ['text-c'], TEXT_1),
1675
('text-m', ['text-b', 'text-d'], TEXT_1),
1676
]
1677
for version_id, parents, lines in test_data:
1678
k1.add_lines(version_id, parents, split_lines(lines))
1679
1680
# This test is actually a bit strict as the order in which they're
1681
# returned is not defined. This matches the current (deterministic)
1682
# behaviour.
1683
expected_data_list = [
1684
# version, options, length, parents
1685
('text-a', ['fulltext'], 122, ()),
1686
('text-b', ['line-delta'], 84, ('text-a',)),
1687
('text-m', ['line-delta'], 84, ('text-b', 'text-d')),
1688
('text-c', ['fulltext'], 121, ()),
1689
('text-d', ['line-delta'], 84, ('text-c',)),
1690
]
1691
format, data_list, reader_callable = k1.get_data_stream(
1692
['text-a', 'text-b', 'text-c', 'text-d', 'text-m'])
1693
self.assertEqual('knit-plain', format)
1694
self.assertEqual(expected_data_list, data_list)
1695
for version_id, options, length, parents in expected_data_list:
1696
bytes = reader_callable(length)
1697
self.assertRecordContentEqual(k1, version_id, bytes)
1698
1699
def assertKnitFilesEqual(self, knit1, knit2):
1700
"""Assert that the contents of the index and data files of two knits are
1701
equal.
1702
"""
1703
self.assertEqual(
1704
knit1.transport.get_bytes(knit1._data._access._filename),
1705
knit2.transport.get_bytes(knit2._data._access._filename))
1706
self.assertEqual(
1707
knit1.transport.get_bytes(knit1._index._filename),
1708
knit2.transport.get_bytes(knit2._index._filename))
1709
1710
def assertKnitValuesEqual(self, left, right):
1711
"""Assert that the texts, annotations and graph of left and right are
1712
the same.
1713
"""
1714
self.assertEqual(set(left.versions()), set(right.versions()))
1715
for version in left.versions():
1716
self.assertEqual(left.get_parents_with_ghosts(version),
1717
right.get_parents_with_ghosts(version))
1718
self.assertEqual(left.get_lines(version),
1719
right.get_lines(version))
1720
self.assertEqual(left.annotate(version),
1721
right.annotate(version))
1722
1723
def test_insert_data_stream_empty(self):
1724
"""Inserting a data stream with no records should not put any data into
1725
the knit.
1726
"""
1727
k1 = self.make_test_knit()
1728
k1.insert_data_stream(
1729
(k1.get_format_signature(), [], lambda ignored: ''))
1730
self.assertEqual('', k1.transport.get_bytes(k1._data._access._filename),
1731
"The .knit should be completely empty.")
1732
self.assertEqual(k1._index.HEADER,
1733
k1.transport.get_bytes(k1._index._filename),
1734
"The .kndx should have nothing apart from the header.")
1735
1736
def test_insert_data_stream_one_record(self):
1737
"""Inserting a data stream with one record from a knit with one record
1738
results in byte-identical files.
1739
"""
1740
source = self.make_test_knit(name='source')
1741
source.add_lines('text-a', [], split_lines(TEXT_1))
1742
data_stream = source.get_data_stream(['text-a'])
1743
target = self.make_test_knit(name='target')
1744
target.insert_data_stream(data_stream)
1745
self.assertKnitFilesEqual(source, target)
1746
1747
def test_insert_data_stream_annotated_unannotated(self):
1748
"""Inserting an annotated datastream to an unannotated knit works."""
1749
# case one - full texts.
1750
source = self.make_test_knit(name='source', annotate=True)
1751
target = self.make_test_knit(name='target', annotate=False)
1752
source.add_lines('text-a', [], split_lines(TEXT_1))
1753
target.insert_data_stream(source.get_data_stream(['text-a']))
1754
self.assertKnitValuesEqual(source, target)
1755
# case two - deltas.
1756
source.add_lines('text-b', ['text-a'], split_lines(TEXT_2))
1757
target.insert_data_stream(source.get_data_stream(['text-b']))
1758
self.assertKnitValuesEqual(source, target)
1759
1760
def test_insert_data_stream_unannotated_annotated(self):
1761
"""Inserting an unannotated datastream to an annotated knit works."""
1762
# case one - full texts.
1763
source = self.make_test_knit(name='source', annotate=False)
1764
target = self.make_test_knit(name='target', annotate=True)
1765
source.add_lines('text-a', [], split_lines(TEXT_1))
1766
target.insert_data_stream(source.get_data_stream(['text-a']))
1767
self.assertKnitValuesEqual(source, target)
1768
# case two - deltas.
1769
source.add_lines('text-b', ['text-a'], split_lines(TEXT_2))
1770
target.insert_data_stream(source.get_data_stream(['text-b']))
1771
self.assertKnitValuesEqual(source, target)
1772
1773
def test_insert_data_stream_records_already_present(self):
1774
"""Insert a data stream where some records are alreday present in the
1775
target, and some not. Only the new records are inserted.
1776
"""
1777
source = self.make_test_knit(name='source')
1778
target = self.make_test_knit(name='target')
1779
# Insert 'text-a' into both source and target
1780
source.add_lines('text-a', [], split_lines(TEXT_1))
1781
target.insert_data_stream(source.get_data_stream(['text-a']))
1782
# Insert 'text-b' into just the source.
1783
source.add_lines('text-b', ['text-a'], split_lines(TEXT_1))
1784
# Get a data stream of both text-a and text-b, and insert it.
1785
data_stream = source.get_data_stream(['text-a', 'text-b'])
1786
target.insert_data_stream(data_stream)
1787
# The source and target will now be identical. This means the text-a
1788
# record was not added a second time.
1789
self.assertKnitFilesEqual(source, target)
1790
1791
def test_insert_data_stream_multiple_records(self):
1792
"""Inserting a data stream of all records from a knit with multiple
1793
records results in byte-identical files.
1794
"""
1795
source = self.make_test_knit(name='source')
1796
source.add_lines('text-a', [], split_lines(TEXT_1))
1797
source.add_lines('text-b', ['text-a'], split_lines(TEXT_1))
1798
source.add_lines('text-c', [], split_lines(TEXT_1))
1799
data_stream = source.get_data_stream(['text-a', 'text-b', 'text-c'])
1800
1801
target = self.make_test_knit(name='target')
1802
target.insert_data_stream(data_stream)
1803
1804
self.assertKnitFilesEqual(source, target)
1805
1806
def test_insert_data_stream_ghost_parent(self):
1807
"""Insert a data stream with a record that has a ghost parent."""
1808
# Make a knit with a record, text-a, that has a ghost parent.
1809
source = self.make_test_knit(name='source')
1810
source.add_lines_with_ghosts('text-a', ['text-ghost'],
1811
split_lines(TEXT_1))
1812
data_stream = source.get_data_stream(['text-a'])
1813
1814
target = self.make_test_knit(name='target')
1815
target.insert_data_stream(data_stream)
1816
1817
self.assertKnitFilesEqual(source, target)
1818
1819
# The target knit object is in a consistent state, i.e. the record we
1820
# just added is immediately visible.
1821
self.assertTrue(target.has_version('text-a'))
1822
self.assertFalse(target.has_version('text-ghost'))
1823
self.assertEqual({'text-a':('text-ghost',)},
1824
target.get_parent_map(['text-a', 'text-ghost']))
1825
self.assertEqual(split_lines(TEXT_1), target.get_lines('text-a'))
1826
1827
def test_insert_data_stream_inconsistent_version_lines(self):
1828
"""Inserting a data stream which has different content for a version_id
1829
than already exists in the knit will raise KnitCorrupt.
1830
"""
1831
source = self.make_test_knit(name='source')
1832
target = self.make_test_knit(name='target')
1833
# Insert a different 'text-a' into both source and target
1834
source.add_lines('text-a', [], split_lines(TEXT_1))
1835
target.add_lines('text-a', [], split_lines(TEXT_2))
1836
# Insert a data stream with conflicting content into the target
1837
data_stream = source.get_data_stream(['text-a'])
1838
self.assertRaises(
1839
errors.KnitCorrupt, target.insert_data_stream, data_stream)
1840
1841
def test_insert_data_stream_inconsistent_version_parents(self):
1842
"""Inserting a data stream which has different parents for a version_id
1843
than already exists in the knit will raise KnitCorrupt.
1844
"""
1845
source = self.make_test_knit(name='source')
1846
target = self.make_test_knit(name='target')
1847
# Insert a different 'text-a' into both source and target. They differ
1848
# only by the parents list, the content is the same.
1849
source.add_lines_with_ghosts('text-a', [], split_lines(TEXT_1))
1850
target.add_lines_with_ghosts('text-a', ['a-ghost'], split_lines(TEXT_1))
1851
# Insert a data stream with conflicting content into the target
1852
data_stream = source.get_data_stream(['text-a'])
1853
self.assertRaises(
1854
errors.KnitCorrupt, target.insert_data_stream, data_stream)
1855
1856
def test_insert_data_stream_unknown_format(self):
1857
"""A data stream in a different format to the target knit cannot be
1858
inserted.
1859
1860
It will raise KnitDataStreamUnknown because the fallback code will fail
1861
to make a knit. In future we may need KnitDataStreamIncompatible again,
1862
for more exotic cases.
1863
"""
1864
data_stream = ('fake-format-signature', [], lambda _: '')
1865
target = self.make_test_knit(name='target')
1866
self.assertRaises(
1867
errors.KnitDataStreamUnknown,
1868
target.insert_data_stream, data_stream)
1869
1870
def test_insert_data_stream_bug_208418(self):
1871
"""You can insert a stream with an incompatible format, even when:
1872
* the stream has a line-delta record,
1873
* whose parent is in the target, also stored as a line-delta
1874
1875
See <https://launchpad.net/bugs/208418>.
1876
"""
1877
base_lines = split_lines(TEXT_1)
1878
# Make the target
1879
target = self.make_test_knit(name='target', annotate=True)
1880
target.add_lines('version-1', [], base_lines)
1881
target.add_lines('version-2', ['version-1'], base_lines + ['a\n'])
1882
# The second record should be a delta.
1883
self.assertEqual('line-delta', target._index.get_method('version-2'))
1884
1885
# Make a source, with a different format, but the same data
1886
source = self.make_test_knit(name='source', annotate=False)
1887
source.add_lines('version-1', [], base_lines)
1888
source.add_lines('version-2', ['version-1'], base_lines + ['a\n'])
1889
# Now add another record, which should be stored as a delta against
1890
# version-2.
1891
source.add_lines('version-3', ['version-2'], base_lines + ['b\n'])
1892
self.assertEqual('line-delta', source._index.get_method('version-3'))
1893
1894
# Make a stream of the new version
1895
data_stream = source.get_data_stream(['version-3'])
1896
# And insert into the target
1897
target.insert_data_stream(data_stream)
1898
# No errors should have been raised.
1899
1900
1901
# * test that a stream of "already present version, then new version"
1902
# inserts correctly.
1903
1904
1905
def assertMadeStreamKnit(self, source_knit, versions, target_knit):
1906
"""Assert that a knit made from a stream is as expected."""
1907
a_stream = source_knit.get_data_stream(versions)
1908
expected_data = a_stream[2](None)
1909
a_stream = source_knit.get_data_stream(versions)
1910
a_knit = target_knit._knit_from_datastream(a_stream)
1911
self.assertEqual(source_knit.factory.__class__,
1912
a_knit.factory.__class__)
1913
self.assertIsInstance(a_knit._data._access, _StreamAccess)
1914
self.assertIsInstance(a_knit._index, _StreamIndex)
1915
self.assertEqual(a_knit._index.data_list, a_stream[1])
1916
self.assertEqual(a_knit._data._access.data, expected_data)
1917
self.assertEqual(a_knit.filename, target_knit.filename)
1918
self.assertEqual(a_knit.transport, target_knit.transport)
1919
self.assertEqual(a_knit._index, a_knit._data._access.stream_index)
1920
self.assertEqual(target_knit, a_knit._data._access.backing_knit)
1921
self.assertIsInstance(a_knit._data._access.orig_factory,
1922
source_knit.factory.__class__)
1923
1924
def test__knit_from_data_stream_empty(self):
1925
"""Create a knit object from a datastream."""
1926
annotated = self.make_test_knit(name='source', annotate=True)
1927
plain = self.make_test_knit(name='target', annotate=False)
1928
# case 1: annotated source
1929
self.assertMadeStreamKnit(annotated, [], annotated)
1930
self.assertMadeStreamKnit(annotated, [], plain)
1931
# case 2: plain source
1932
self.assertMadeStreamKnit(plain, [], annotated)
1933
self.assertMadeStreamKnit(plain, [], plain)
1934
1935
def test__knit_from_data_stream_unknown_format(self):
1936
annotated = self.make_test_knit(name='source', annotate=True)
1937
self.assertRaises(errors.KnitDataStreamUnknown,
1938
annotated._knit_from_datastream, ("unknown", None, None))
1939
1940
1941
TEXT_1 = """\
1942
Banana cup cakes:
1943
1944
- bananas
1945
- eggs
1946
- broken tea cups
1947
"""
1948
1949
TEXT_1A = """\
1950
Banana cup cake recipe
1951
(serves 6)
1952
1953
- bananas
1954
- eggs
1955
- broken tea cups
1956
- self-raising flour
1957
"""
1958
1959
TEXT_1B = """\
1960
Banana cup cake recipe
1961
1962
- bananas (do not use plantains!!!)
1963
- broken tea cups
1964
- flour
1965
"""
1966
1967
delta_1_1a = """\
1968
0,1,2
1969
Banana cup cake recipe
1970
(serves 6)
1971
5,5,1
1972
- self-raising flour
1973
"""
1974
1975
TEXT_2 = """\
1976
Boeuf bourguignon
1977
1978
- beef
1979
- red wine
1980
- small onions
1981
- carrot
1982
- mushrooms
1983
"""
1984
1985
AB_MERGE_TEXT="""unchanged|Banana cup cake recipe
1986
new-a|(serves 6)
1987
unchanged|
1988
killed-b|- bananas
1989
killed-b|- eggs
1990
new-b|- bananas (do not use plantains!!!)
1991
unchanged|- broken tea cups
1992
new-a|- self-raising flour
1993
new-b|- flour
1994
"""
1995
AB_MERGE=[tuple(l.split('|')) for l in AB_MERGE_TEXT.splitlines(True)]
1996
1997
1998
def line_delta(from_lines, to_lines):
1999
"""Generate line-based delta from one text to another"""
2000
s = difflib.SequenceMatcher(None, from_lines, to_lines)
2001
for op in s.get_opcodes():
2002
if op[0] == 'equal':
2003
continue
2004
yield '%d,%d,%d\n' % (op[1], op[2], op[4]-op[3])
2005
for i in range(op[3], op[4]):
2006
yield to_lines[i]
2007
2008
2009
def apply_line_delta(basis_lines, delta_lines):
2010
"""Apply a line-based perfect diff
2011
2012
basis_lines -- text to apply the patch to
2013
delta_lines -- diff instructions and content
2014
"""
2015
out = basis_lines[:]
2016
i = 0
2017
offset = 0
2018
while i < len(delta_lines):
2019
l = delta_lines[i]
2020
a, b, c = map(long, l.split(','))
2021
i = i + 1
2022
out[offset+a:offset+b] = delta_lines[i:i+c]
2023
i = i + c
2024
offset = offset + (b - a) + c
2025
return out
2026
2027
2028
class TestWeaveToKnit(KnitTests):
2029
2030
def test_weave_to_knit_matches(self):
2031
# check that the WeaveToKnit is_compatible function
2032
# registers True for a Weave to a Knit.
2033
w = Weave(get_scope=lambda:None)
2034
k = self.make_test_knit()
2035
self.failUnless(WeaveToKnit.is_compatible(w, k))
2036
self.failIf(WeaveToKnit.is_compatible(k, w))
2037
self.failIf(WeaveToKnit.is_compatible(w, w))
2038
self.failIf(WeaveToKnit.is_compatible(k, k))
923
2039
924
2040
925
2041
class TestKnitIndex(KnitTests):
928
2044
"""Adding versions to the index should update the lookup dict"""
929
2045
knit = self.make_test_knit()
930
2046
idx = knit._index
931
idx.add_records([(('a-1',), ['fulltext'], (('a-1',), 0, 0), [])])
2047
idx.add_version('a-1', ['fulltext'], (None, 0, 0), [])
932
2048
self.check_file_contents('test.kndx',
933
2049
'# bzr knit index 8\n'
934
2050
'\n'
935
2051
'a-1 fulltext 0 0 :'
936
2052
)
937
idx.add_records([
938
(('a-2',), ['fulltext'], (('a-2',), 0, 0), [('a-1',)]),
939
(('a-3',), ['fulltext'], (('a-3',), 0, 0), [('a-2',)]),
940
])
2053
idx.add_versions([('a-2', ['fulltext'], (None, 0, 0), ['a-1']),
2054
('a-3', ['fulltext'], (None, 0, 0), ['a-2']),
2055
])
941
2056
self.check_file_contents('test.kndx',
942
2057
'# bzr knit index 8\n'
943
2058
'\n'
945
2060
'a-2 fulltext 0 0 0 :\n'
946
2061
'a-3 fulltext 0 0 1 :'
947
2062
)
948
self.assertEqual(set([('a-3',), ('a-1',), ('a-2',)]), idx.keys())
949
self.assertEqual({
950
('a-1',): ((('a-1',), 0, 0), None, (), ('fulltext', False)),
951
('a-2',): ((('a-2',), 0, 0), None, (('a-1',),), ('fulltext', False)),
952
('a-3',): ((('a-3',), 0, 0), None, (('a-2',),), ('fulltext', False)),
953
}, idx.get_build_details(idx.keys()))
954
self.assertEqual({('a-1',):(),
955
('a-2',):(('a-1',),),
956
('a-3',):(('a-2',),),},
957
idx.get_parent_map(idx.keys()))
2063
self.assertEqual(['a-1', 'a-2', 'a-3'], idx._history)
2064
self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, (), 0),
2065
'a-2':('a-2', ['fulltext'], 0, 0, ('a-1',), 1),
2066
'a-3':('a-3', ['fulltext'], 0, 0, ('a-2',), 2),
2067
}, idx._cache)
958
2068
959
2069
def test_add_versions_fails_clean(self):
960
2070
"""If add_versions fails in the middle, it restores a pristine state.
970
2080
971
2081
knit = self.make_test_knit()
972
2082
idx = knit._index
973
idx.add_records([(('a-1',), ['fulltext'], (('a-1',), 0, 0), [])])
2083
idx.add_version('a-1', ['fulltext'], (None, 0, 0), [])
974
2084
975
2085
class StopEarly(Exception):
976
2086
pass
977
2087
978
2088
def generate_failure():
979
2089
"""Add some entries and then raise an exception"""
980
yield (('a-2',), ['fulltext'], (None, 0, 0), ('a-1',))
981
yield (('a-3',), ['fulltext'], (None, 0, 0), ('a-2',))
2090
yield ('a-2', ['fulltext'], (None, 0, 0), ('a-1',))
2091
yield ('a-3', ['fulltext'], (None, 0, 0), ('a-2',))
982
2092
raise StopEarly()
983
2093
984
2094
# Assert the pre-condition
985
def assertA1Only():
986
self.assertEqual(set([('a-1',)]), set(idx.keys()))
987
self.assertEqual(
988
{('a-1',): ((('a-1',), 0, 0), None, (), ('fulltext', False))},
989
idx.get_build_details([('a-1',)]))
990
self.assertEqual({('a-1',):()}, idx.get_parent_map(idx.keys()))
991
992
assertA1Only()
993
self.assertRaises(StopEarly, idx.add_records, generate_failure())
2095
self.assertEqual(['a-1'], idx._history)
2096
self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, (), 0)}, idx._cache)
2097
2098
self.assertRaises(StopEarly, idx.add_versions, generate_failure())
2099
994
2100
# And it shouldn't be modified
995
assertA1Only()
2101
self.assertEqual(['a-1'], idx._history)
2102
self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, (), 0)}, idx._cache)
996
2103
997
2104
def test_knit_index_ignores_empty_files(self):
998
2105
# There was a race condition in older bzr, where a ^C at the right time
1007
2114
def test_knit_index_checks_header(self):
1008
2115
t = get_transport('.')
1009
2116
t.put_bytes('test.kndx', '# not really a knit header\n\n')
1010
k = self.make_test_knit()
1011
self.assertRaises(KnitHeaderError, k.keys)
2117
2118
self.assertRaises(KnitHeaderError, self.make_test_knit)
1012
2119
1013
2120
1014
2121
class TestGraphIndexKnit(KnitTests):
1053
2160
add_callback = self.catch_add
1054
2161
else:
1055
2162
add_callback = None
1056
return _KnitGraphIndex(combined_index, lambda:True, deltas=deltas,
2163
return KnitGraphIndex(combined_index, deltas=deltas,
1057
2164
add_callback=add_callback)
1058
2165
1059
def test_keys(self):
1060
index = self.two_graph_index()
1061
self.assertEqual(set([('tail',), ('tip',), ('parent',), ('separate',)]),
1062
set(index.keys()))
2166
def test_get_ancestry(self):
2167
# get_ancestry is defined as eliding ghosts, not erroring.
2168
index = self.two_graph_index()
2169
self.assertEqual([], index.get_ancestry([]))
2170
self.assertEqual(['separate'], index.get_ancestry(['separate']))
2171
self.assertEqual(['tail'], index.get_ancestry(['tail']))
2172
self.assertEqual(['tail', 'parent'], index.get_ancestry(['parent']))
2173
self.assertEqual(['tail', 'parent', 'tip'], index.get_ancestry(['tip']))
2174
self.assertTrue(index.get_ancestry(['tip', 'separate']) in
2175
(['tail', 'parent', 'tip', 'separate'],
2176
['separate', 'tail', 'parent', 'tip'],
2177
))
2178
# and without topo_sort
2179
self.assertEqual(set(['separate']),
2180
set(index.get_ancestry(['separate'], topo_sorted=False)))
2181
self.assertEqual(set(['tail']),
2182
set(index.get_ancestry(['tail'], topo_sorted=False)))
2183
self.assertEqual(set(['tail', 'parent']),
2184
set(index.get_ancestry(['parent'], topo_sorted=False)))
2185
self.assertEqual(set(['tail', 'parent', 'tip']),
2186
set(index.get_ancestry(['tip'], topo_sorted=False)))
2187
self.assertEqual(set(['separate', 'tail', 'parent', 'tip']),
2188
set(index.get_ancestry(['tip', 'separate'])))
2189
# asking for a ghost makes it go boom.
2190
self.assertRaises(errors.RevisionNotPresent, index.get_ancestry, ['ghost'])
2191
2192
def test_get_ancestry_with_ghosts(self):
2193
index = self.two_graph_index()
2194
self.assertEqual([], index.get_ancestry_with_ghosts([]))
2195
self.assertEqual(['separate'], index.get_ancestry_with_ghosts(['separate']))
2196
self.assertEqual(['tail'], index.get_ancestry_with_ghosts(['tail']))
2197
self.assertTrue(index.get_ancestry_with_ghosts(['parent']) in
2198
(['tail', 'ghost', 'parent'],
2199
['ghost', 'tail', 'parent'],
2200
))
2201
self.assertTrue(index.get_ancestry_with_ghosts(['tip']) in
2202
(['tail', 'ghost', 'parent', 'tip'],
2203
['ghost', 'tail', 'parent', 'tip'],
2204
))
2205
self.assertTrue(index.get_ancestry_with_ghosts(['tip', 'separate']) in
2206
(['tail', 'ghost', 'parent', 'tip', 'separate'],
2207
['ghost', 'tail', 'parent', 'tip', 'separate'],
2208
['separate', 'tail', 'ghost', 'parent', 'tip'],
2209
['separate', 'ghost', 'tail', 'parent', 'tip'],
2210
))
2211
# asking for a ghost makes it go boom.
2212
self.assertRaises(errors.RevisionNotPresent, index.get_ancestry_with_ghosts, ['ghost'])
2213
2214
def test_num_versions(self):
2215
index = self.two_graph_index()
2216
self.assertEqual(4, index.num_versions())
2217
2218
def test_get_versions(self):
2219
index = self.two_graph_index()
2220
self.assertEqual(set(['tail', 'tip', 'parent', 'separate']),
2221
set(index.get_versions()))
2222
2223
def test_has_version(self):
2224
index = self.two_graph_index()
2225
self.assertTrue(index.has_version('tail'))
2226
self.assertFalse(index.has_version('ghost'))
1063
2227
1064
2228
def test_get_position(self):
1065
2229
index = self.two_graph_index()
1066
self.assertEqual((index._graph_index._indices[0], 0, 100), index.get_position(('tip',)))
1067
self.assertEqual((index._graph_index._indices[1], 100, 78), index.get_position(('parent',)))
2230
self.assertEqual((index._graph_index._indices[0], 0, 100), index.get_position('tip'))
2231
self.assertEqual((index._graph_index._indices[1], 100, 78), index.get_position('parent'))
1068
2232
1069
2233
def test_get_method_deltas(self):
1070
2234
index = self.two_graph_index(deltas=True)
1071
self.assertEqual('fulltext', index.get_method(('tip',)))
1072
self.assertEqual('line-delta', index.get_method(('parent',)))
2235
self.assertEqual('fulltext', index.get_method('tip'))
2236
self.assertEqual('line-delta', index.get_method('parent'))
1073
2237
1074
2238
def test_get_method_no_deltas(self):
1075
2239
# check that the parent-history lookup is ignored with deltas=False.
1076
2240
index = self.two_graph_index(deltas=False)
1077
self.assertEqual('fulltext', index.get_method(('tip',)))
1078
self.assertEqual('fulltext', index.get_method(('parent',)))
2241
self.assertEqual('fulltext', index.get_method('tip'))
2242
self.assertEqual('fulltext', index.get_method('parent'))
1079
2243
1080
2244
def test_get_options_deltas(self):
1081
2245
index = self.two_graph_index(deltas=True)
1082
self.assertEqual(['fulltext', 'no-eol'], index.get_options(('tip',)))
1083
self.assertEqual(['line-delta'], index.get_options(('parent',)))
2246
self.assertEqual(['fulltext', 'no-eol'], index.get_options('tip'))
2247
self.assertEqual(['line-delta'], index.get_options('parent'))
1084
2248
1085
2249
def test_get_options_no_deltas(self):
1086
2250
# check that the parent-history lookup is ignored with deltas=False.
1087
2251
index = self.two_graph_index(deltas=False)
1088
self.assertEqual(['fulltext', 'no-eol'], index.get_options(('tip',)))
1089
self.assertEqual(['fulltext'], index.get_options(('parent',)))
1090
1091
def test_get_parent_map(self):
1092
index = self.two_graph_index()
1093
self.assertEqual({('parent',):(('tail',), ('ghost',))},
1094
index.get_parent_map([('parent',), ('ghost',)]))
2252
self.assertEqual(['fulltext', 'no-eol'], index.get_options('tip'))
2253
self.assertEqual(['fulltext'], index.get_options('parent'))
2254
2255
def test_get_parents_with_ghosts(self):
2256
index = self.two_graph_index()
2257
self.assertEqual(('tail', 'ghost'), index.get_parents_with_ghosts('parent'))
2258
# and errors on ghosts.
2259
self.assertRaises(errors.RevisionNotPresent,
2260
index.get_parents_with_ghosts, 'ghost')
2261
2262
def test_check_versions_present(self):
2263
# ghosts should not be considered present
2264
index = self.two_graph_index()
2265
self.assertRaises(RevisionNotPresent, index.check_versions_present,
2266
['ghost'])
2267
self.assertRaises(RevisionNotPresent, index.check_versions_present,
2268
['tail', 'ghost'])
2269
index.check_versions_present(['tail', 'separate'])
1095
2270
1096
2271
def catch_add(self, entries):
1097
2272
self.caught_entries.append(entries)
1098
2273
1099
2274
def test_add_no_callback_errors(self):
1100
2275
index = self.two_graph_index()
1101
self.assertRaises(errors.ReadOnlyError, index.add_records,
1102
[(('new',), 'fulltext,no-eol', (None, 50, 60), ['separate'])])
2276
self.assertRaises(errors.ReadOnlyError, index.add_version,
2277
'new', 'fulltext,no-eol', (None, 50, 60), ['separate'])
1103
2278
1104
2279
def test_add_version_smoke(self):
1105
2280
index = self.two_graph_index(catch_adds=True)
1106
index.add_records([(('new',), 'fulltext,no-eol', (None, 50, 60),
1107
[('separate',)])])
2281
index.add_version('new', 'fulltext,no-eol', (None, 50, 60), ['separate'])
1108
2282
self.assertEqual([[(('new', ), 'N50 60', ((('separate',),),))]],
1109
2283
self.caught_entries)
1110
2284
1111
2285
def test_add_version_delta_not_delta_index(self):
1112
2286
index = self.two_graph_index(catch_adds=True)
1113
self.assertRaises(errors.KnitCorrupt, index.add_records,
1114
[(('new',), 'no-eol,line-delta', (None, 0, 100), [('parent',)])])
2287
self.assertRaises(errors.KnitCorrupt, index.add_version,
2288
'new', 'no-eol,line-delta', (None, 0, 100), ['parent'])
1115
2289
self.assertEqual([], self.caught_entries)
1116
2290
1117
2291
def test_add_version_same_dup(self):
1118
2292
index = self.two_graph_index(catch_adds=True)
1119
2293
# options can be spelt two different ways
1120
index.add_records([(('tip',), 'fulltext,no-eol', (None, 0, 100), [('parent',)])])
1121
index.add_records([(('tip',), 'no-eol,fulltext', (None, 0, 100), [('parent',)])])
1122
# position/length are ignored (because each pack could have fulltext or
1123
# delta, and be at a different position.
1124
index.add_records([(('tip',), 'fulltext,no-eol', (None, 50, 100),
1125
[('parent',)])])
1126
index.add_records([(('tip',), 'fulltext,no-eol', (None, 0, 1000),
1127
[('parent',)])])
1128
# but neither should have added data:
1129
self.assertEqual([[], [], [], []], self.caught_entries)
2294
index.add_version('tip', 'fulltext,no-eol', (None, 0, 100), ['parent'])
2295
index.add_version('tip', 'no-eol,fulltext', (None, 0, 100), ['parent'])
2296
# but neither should have added data.
2297
self.assertEqual([[], []], self.caught_entries)
1130
2298
1131
2299
def test_add_version_different_dup(self):
1132
2300
index = self.two_graph_index(deltas=True, catch_adds=True)
1133
2301
# change options
1134
self.assertRaises(errors.KnitCorrupt, index.add_records,
1135
[(('tip',), 'no-eol,line-delta', (None, 0, 100), [('parent',)])])
1136
self.assertRaises(errors.KnitCorrupt, index.add_records,
1137
[(('tip',), 'line-delta,no-eol', (None, 0, 100), [('parent',)])])
1138
self.assertRaises(errors.KnitCorrupt, index.add_records,
1139
[(('tip',), 'fulltext', (None, 0, 100), [('parent',)])])
2302
self.assertRaises(errors.KnitCorrupt, index.add_version,
2303
'tip', 'no-eol,line-delta', (None, 0, 100), ['parent'])
2304
self.assertRaises(errors.KnitCorrupt, index.add_version,
2305
'tip', 'line-delta,no-eol', (None, 0, 100), ['parent'])
2306
self.assertRaises(errors.KnitCorrupt, index.add_version,
2307
'tip', 'fulltext', (None, 0, 100), ['parent'])
2308
# position/length
2309
self.assertRaises(errors.KnitCorrupt, index.add_version,
2310
'tip', 'fulltext,no-eol', (None, 50, 100), ['parent'])
2311
self.assertRaises(errors.KnitCorrupt, index.add_version,
2312
'tip', 'fulltext,no-eol', (None, 0, 1000), ['parent'])
1140
2313
# parents
1141
self.assertRaises(errors.KnitCorrupt, index.add_records,
1142
[(('tip',), 'fulltext,no-eol', (None, 0, 100), [])])
2314
self.assertRaises(errors.KnitCorrupt, index.add_version,
2315
'tip', 'fulltext,no-eol', (None, 0, 100), [])
1143
2316
self.assertEqual([], self.caught_entries)
1144
2317
1145
2318
def test_add_versions_nodeltas(self):
1146
2319
index = self.two_graph_index(catch_adds=True)
1147
index.add_records([
1148
(('new',), 'fulltext,no-eol', (None, 50, 60), [('separate',)]),
1149
(('new2',), 'fulltext', (None, 0, 6), [('new',)]),
2320
index.add_versions([
2321
('new', 'fulltext,no-eol', (None, 50, 60), ['separate']),
2322
('new2', 'fulltext', (None, 0, 6), ['new']),
1150
2323
])
1151
2324
self.assertEqual([(('new', ), 'N50 60', ((('separate',),),)),
1152
2325
(('new2', ), ' 0 6', ((('new',),),))],
1155
2328
1156
2329
def test_add_versions_deltas(self):
1157
2330
index = self.two_graph_index(deltas=True, catch_adds=True)
1158
index.add_records([
1159
(('new',), 'fulltext,no-eol', (None, 50, 60), [('separate',)]),
1160
(('new2',), 'line-delta', (None, 0, 6), [('new',)]),
2331
index.add_versions([
2332
('new', 'fulltext,no-eol', (None, 50, 60), ['separate']),
2333
('new2', 'line-delta', (None, 0, 6), ['new']),
1161
2334
])
1162
2335
self.assertEqual([(('new', ), 'N50 60', ((('separate',),), ())),
1163
2336
(('new2', ), ' 0 6', ((('new',),), (('new',),), ))],
1166
2339
1167
2340
def test_add_versions_delta_not_delta_index(self):
1168
2341
index = self.two_graph_index(catch_adds=True)
1169
self.assertRaises(errors.KnitCorrupt, index.add_records,
1170
[(('new',), 'no-eol,line-delta', (None, 0, 100), [('parent',)])])
2342
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2343
[('new', 'no-eol,line-delta', (None, 0, 100), ['parent'])])
1171
2344
self.assertEqual([], self.caught_entries)
1172
2345
1173
2346
def test_add_versions_random_id_accepted(self):
1174
2347
index = self.two_graph_index(catch_adds=True)
1175
index.add_records([], random_id=True)
2348
index.add_versions([], random_id=True)
1176
2349
1177
2350
def test_add_versions_same_dup(self):
1178
2351
index = self.two_graph_index(catch_adds=True)
1179
2352
# options can be spelt two different ways
1180
index.add_records([(('tip',), 'fulltext,no-eol', (None, 0, 100),
1181
[('parent',)])])
1182
index.add_records([(('tip',), 'no-eol,fulltext', (None, 0, 100),
1183
[('parent',)])])
1184
# position/length are ignored (because each pack could have fulltext or
1185
# delta, and be at a different position.
1186
index.add_records([(('tip',), 'fulltext,no-eol', (None, 50, 100),
1187
[('parent',)])])
1188
index.add_records([(('tip',), 'fulltext,no-eol', (None, 0, 1000),
1189
[('parent',)])])
2353
index.add_versions([('tip', 'fulltext,no-eol', (None, 0, 100), ['parent'])])
2354
index.add_versions([('tip', 'no-eol,fulltext', (None, 0, 100), ['parent'])])
1190
2355
# but neither should have added data.
1191
self.assertEqual([[], [], [], []], self.caught_entries)
2356
self.assertEqual([[], []], self.caught_entries)
1192
2357
1193
2358
def test_add_versions_different_dup(self):
1194
2359
index = self.two_graph_index(deltas=True, catch_adds=True)
1195
2360
# change options
1196
self.assertRaises(errors.KnitCorrupt, index.add_records,
1197
[(('tip',), 'no-eol,line-delta', (None, 0, 100), [('parent',)])])
1198
self.assertRaises(errors.KnitCorrupt, index.add_records,
1199
[(('tip',), 'line-delta,no-eol', (None, 0, 100), [('parent',)])])
1200
self.assertRaises(errors.KnitCorrupt, index.add_records,
1201
[(('tip',), 'fulltext', (None, 0, 100), [('parent',)])])
2361
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2362
[('tip', 'no-eol,line-delta', (None, 0, 100), ['parent'])])
2363
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2364
[('tip', 'line-delta,no-eol', (None, 0, 100), ['parent'])])
2365
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2366
[('tip', 'fulltext', (None, 0, 100), ['parent'])])
2367
# position/length
2368
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2369
[('tip', 'fulltext,no-eol', (None, 50, 100), ['parent'])])
2370
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2371
[('tip', 'fulltext,no-eol', (None, 0, 1000), ['parent'])])
1202
2372
# parents
1203
self.assertRaises(errors.KnitCorrupt, index.add_records,
1204
[(('tip',), 'fulltext,no-eol', (None, 0, 100), [])])
2373
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2374
[('tip', 'fulltext,no-eol', (None, 0, 100), [])])
1205
2375
# change options in the second record
1206
self.assertRaises(errors.KnitCorrupt, index.add_records,
1207
[(('tip',), 'fulltext,no-eol', (None, 0, 100), [('parent',)]),
1208
(('tip',), 'no-eol,line-delta', (None, 0, 100), [('parent',)])])
2376
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2377
[('tip', 'fulltext,no-eol', (None, 0, 100), ['parent']),
2378
('tip', 'no-eol,line-delta', (None, 0, 100), ['parent'])])
1209
2379
self.assertEqual([], self.caught_entries)
1210
2380
1211
1212
2381
class TestNoParentsGraphIndexKnit(KnitTests):
1213
"""Tests for knits using _KnitGraphIndex with no parents."""
2382
"""Tests for knits using KnitGraphIndex with no parents."""
1214
2383
1215
2384
def make_g_index(self, name, ref_lists=0, nodes=[]):
1216
2385
builder = GraphIndexBuilder(ref_lists)
1223
2392
1224
2393
def test_parents_deltas_incompatible(self):
1225
2394
index = CombinedGraphIndex([])
1226
self.assertRaises(errors.KnitError, _KnitGraphIndex, lambda:True,
1227
index, deltas=True, parents=False)
2395
self.assertRaises(errors.KnitError, KnitGraphIndex, index,
2396
deltas=True, parents=False)
1228
2397
1229
2398
def two_graph_index(self, catch_adds=False):
1230
2399
"""Build a two-graph index.
1246
2415
add_callback = self.catch_add
1247
2416
else:
1248
2417
add_callback = None
1249
return _KnitGraphIndex(combined_index, lambda:True, parents=False,
2418
return KnitGraphIndex(combined_index, parents=False,
1250
2419
add_callback=add_callback)
1251
2420
1252
def test_keys(self):
1253
index = self.two_graph_index()
1254
self.assertEqual(set([('tail',), ('tip',), ('parent',), ('separate',)]),
1255
set(index.keys()))
2421
def test_get_ancestry(self):
2422
# with no parents, ancestry is always just the key.
2423
index = self.two_graph_index()
2424
self.assertEqual([], index.get_ancestry([]))
2425
self.assertEqual(['separate'], index.get_ancestry(['separate']))
2426
self.assertEqual(['tail'], index.get_ancestry(['tail']))
2427
self.assertEqual(['parent'], index.get_ancestry(['parent']))
2428
self.assertEqual(['tip'], index.get_ancestry(['tip']))
2429
self.assertTrue(index.get_ancestry(['tip', 'separate']) in
2430
(['tip', 'separate'],
2431
['separate', 'tip'],
2432
))
2433
# asking for a ghost makes it go boom.
2434
self.assertRaises(errors.RevisionNotPresent, index.get_ancestry, ['ghost'])
2435
2436
def test_get_ancestry_with_ghosts(self):
2437
index = self.two_graph_index()
2438
self.assertEqual([], index.get_ancestry_with_ghosts([]))
2439
self.assertEqual(['separate'], index.get_ancestry_with_ghosts(['separate']))
2440
self.assertEqual(['tail'], index.get_ancestry_with_ghosts(['tail']))
2441
self.assertEqual(['parent'], index.get_ancestry_with_ghosts(['parent']))
2442
self.assertEqual(['tip'], index.get_ancestry_with_ghosts(['tip']))
2443
self.assertTrue(index.get_ancestry_with_ghosts(['tip', 'separate']) in
2444
(['tip', 'separate'],
2445
['separate', 'tip'],
2446
))
2447
# asking for a ghost makes it go boom.
2448
self.assertRaises(errors.RevisionNotPresent, index.get_ancestry_with_ghosts, ['ghost'])
2449
2450
def test_num_versions(self):
2451
index = self.two_graph_index()
2452
self.assertEqual(4, index.num_versions())
2453
2454
def test_get_versions(self):
2455
index = self.two_graph_index()
2456
self.assertEqual(set(['tail', 'tip', 'parent', 'separate']),
2457
set(index.get_versions()))
2458
2459
def test_has_version(self):
2460
index = self.two_graph_index()
2461
self.assertTrue(index.has_version('tail'))
2462
self.assertFalse(index.has_version('ghost'))
1256
2463
1257
2464
def test_get_position(self):
1258
2465
index = self.two_graph_index()
1259
self.assertEqual((index._graph_index._indices[0], 0, 100),
1260
index.get_position(('tip',)))
1261
self.assertEqual((index._graph_index._indices[1], 100, 78),
1262
index.get_position(('parent',)))
2466
self.assertEqual((index._graph_index._indices[0], 0, 100), index.get_position('tip'))
2467
self.assertEqual((index._graph_index._indices[1], 100, 78), index.get_position('parent'))
1263
2468
1264
2469
def test_get_method(self):
1265
2470
index = self.two_graph_index()
1266
self.assertEqual('fulltext', index.get_method(('tip',)))
1267
self.assertEqual(['fulltext'], index.get_options(('parent',)))
2471
self.assertEqual('fulltext', index.get_method('tip'))
2472
self.assertEqual(['fulltext'], index.get_options('parent'))
1268
2473
1269
2474
def test_get_options(self):
1270
2475
index = self.two_graph_index()
1271
self.assertEqual(['fulltext', 'no-eol'], index.get_options(('tip',)))
1272
self.assertEqual(['fulltext'], index.get_options(('parent',)))
1273
1274
def test_get_parent_map(self):
1275
index = self.two_graph_index()
1276
self.assertEqual({('parent',):None},
1277
index.get_parent_map([('parent',), ('ghost',)]))
2476
self.assertEqual(['fulltext', 'no-eol'], index.get_options('tip'))
2477
self.assertEqual(['fulltext'], index.get_options('parent'))
2478
2479
def test_get_parents_with_ghosts(self):
2480
index = self.two_graph_index()
2481
self.assertEqual((), index.get_parents_with_ghosts('parent'))
2482
# and errors on ghosts.
2483
self.assertRaises(errors.RevisionNotPresent,
2484
index.get_parents_with_ghosts, 'ghost')
2485
2486
def test_check_versions_present(self):
2487
index = self.two_graph_index()
2488
self.assertRaises(RevisionNotPresent, index.check_versions_present,
2489
['missing'])
2490
self.assertRaises(RevisionNotPresent, index.check_versions_present,
2491
['tail', 'missing'])
2492
index.check_versions_present(['tail', 'separate'])
1278
2493
1279
2494
def catch_add(self, entries):
1280
2495
self.caught_entries.append(entries)
1281
2496
1282
2497
def test_add_no_callback_errors(self):
1283
2498
index = self.two_graph_index()
1284
self.assertRaises(errors.ReadOnlyError, index.add_records,
1285
[(('new',), 'fulltext,no-eol', (None, 50, 60), [('separate',)])])
2499
self.assertRaises(errors.ReadOnlyError, index.add_version,
2500
'new', 'fulltext,no-eol', (None, 50, 60), ['separate'])
1286
2501
1287
2502
def test_add_version_smoke(self):
1288
2503
index = self.two_graph_index(catch_adds=True)
1289
index.add_records([(('new',), 'fulltext,no-eol', (None, 50, 60), [])])
2504
index.add_version('new', 'fulltext,no-eol', (None, 50, 60), [])
1290
2505
self.assertEqual([[(('new', ), 'N50 60')]],
1291
2506
self.caught_entries)
1292
2507
1293
2508
def test_add_version_delta_not_delta_index(self):
1294
2509
index = self.two_graph_index(catch_adds=True)
1295
self.assertRaises(errors.KnitCorrupt, index.add_records,
1296
[(('new',), 'no-eol,line-delta', (None, 0, 100), [])])
2510
self.assertRaises(errors.KnitCorrupt, index.add_version,
2511
'new', 'no-eol,line-delta', (None, 0, 100), [])
1297
2512
self.assertEqual([], self.caught_entries)
1298
2513
1299
2514
def test_add_version_same_dup(self):
1300
2515
index = self.two_graph_index(catch_adds=True)
1301
2516
# options can be spelt two different ways
1302
index.add_records([(('tip',), 'fulltext,no-eol', (None, 0, 100), [])])
1303
index.add_records([(('tip',), 'no-eol,fulltext', (None, 0, 100), [])])
1304
# position/length are ignored (because each pack could have fulltext or
1305
# delta, and be at a different position.
1306
index.add_records([(('tip',), 'fulltext,no-eol', (None, 50, 100), [])])
1307
index.add_records([(('tip',), 'fulltext,no-eol', (None, 0, 1000), [])])
2517
index.add_version('tip', 'fulltext,no-eol', (None, 0, 100), [])
2518
index.add_version('tip', 'no-eol,fulltext', (None, 0, 100), [])
1308
2519
# but neither should have added data.
1309
self.assertEqual([[], [], [], []], self.caught_entries)
2520
self.assertEqual([[], []], self.caught_entries)
1310
2521
1311
2522
def test_add_version_different_dup(self):
1312
2523
index = self.two_graph_index(catch_adds=True)
1313
2524
# change options
1314
self.assertRaises(errors.KnitCorrupt, index.add_records,
1315
[(('tip',), 'no-eol,line-delta', (None, 0, 100), [])])
1316
self.assertRaises(errors.KnitCorrupt, index.add_records,
1317
[(('tip',), 'line-delta,no-eol', (None, 0, 100), [])])
1318
self.assertRaises(errors.KnitCorrupt, index.add_records,
1319
[(('tip',), 'fulltext', (None, 0, 100), [])])
2525
self.assertRaises(errors.KnitCorrupt, index.add_version,
2526
'tip', 'no-eol,line-delta', (None, 0, 100), [])
2527
self.assertRaises(errors.KnitCorrupt, index.add_version,
2528
'tip', 'line-delta,no-eol', (None, 0, 100), [])
2529
self.assertRaises(errors.KnitCorrupt, index.add_version,
2530
'tip', 'fulltext', (None, 0, 100), [])
2531
# position/length
2532
self.assertRaises(errors.KnitCorrupt, index.add_version,
2533
'tip', 'fulltext,no-eol', (None, 50, 100), [])
2534
self.assertRaises(errors.KnitCorrupt, index.add_version,
2535
'tip', 'fulltext,no-eol', (None, 0, 1000), [])
1320
2536
# parents
1321
self.assertRaises(errors.KnitCorrupt, index.add_records,
1322
[(('tip',), 'fulltext,no-eol', (None, 0, 100), [('parent',)])])
2537
self.assertRaises(errors.KnitCorrupt, index.add_version,
2538
'tip', 'fulltext,no-eol', (None, 0, 100), ['parent'])
1323
2539
self.assertEqual([], self.caught_entries)
1324
2540
1325
2541
def test_add_versions(self):
1326
2542
index = self.two_graph_index(catch_adds=True)
1327
index.add_records([
1328
(('new',), 'fulltext,no-eol', (None, 50, 60), []),
1329
(('new2',), 'fulltext', (None, 0, 6), []),
2543
index.add_versions([
2544
('new', 'fulltext,no-eol', (None, 50, 60), []),
2545
('new2', 'fulltext', (None, 0, 6), []),
1330
2546
])
1331
2547
self.assertEqual([(('new', ), 'N50 60'), (('new2', ), ' 0 6')],
1332
2548
sorted(self.caught_entries[0]))
1334
2550
1335
2551
def test_add_versions_delta_not_delta_index(self):
1336
2552
index = self.two_graph_index(catch_adds=True)
1337
self.assertRaises(errors.KnitCorrupt, index.add_records,
1338
[(('new',), 'no-eol,line-delta', (None, 0, 100), [('parent',)])])
2553
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2554
[('new', 'no-eol,line-delta', (None, 0, 100), ['parent'])])
1339
2555
self.assertEqual([], self.caught_entries)
1340
2556
1341
2557
def test_add_versions_parents_not_parents_index(self):
1342
2558
index = self.two_graph_index(catch_adds=True)
1343
self.assertRaises(errors.KnitCorrupt, index.add_records,
1344
[(('new',), 'no-eol,fulltext', (None, 0, 100), [('parent',)])])
2559
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2560
[('new', 'no-eol,fulltext', (None, 0, 100), ['parent'])])
1345
2561
self.assertEqual([], self.caught_entries)
1346
2562
1347
2563
def test_add_versions_random_id_accepted(self):
1348
2564
index = self.two_graph_index(catch_adds=True)
1349
index.add_records([], random_id=True)
2565
index.add_versions([], random_id=True)
1350
2566
1351
2567
def test_add_versions_same_dup(self):
1352
2568
index = self.two_graph_index(catch_adds=True)
1353
2569
# options can be spelt two different ways
1354
index.add_records([(('tip',), 'fulltext,no-eol', (None, 0, 100), [])])
1355
index.add_records([(('tip',), 'no-eol,fulltext', (None, 0, 100), [])])
1356
# position/length are ignored (because each pack could have fulltext or
1357
# delta, and be at a different position.
1358
index.add_records([(('tip',), 'fulltext,no-eol', (None, 50, 100), [])])
1359
index.add_records([(('tip',), 'fulltext,no-eol', (None, 0, 1000), [])])
2570
index.add_versions([('tip', 'fulltext,no-eol', (None, 0, 100), [])])
2571
index.add_versions([('tip', 'no-eol,fulltext', (None, 0, 100), [])])
1360
2572
# but neither should have added data.
1361
self.assertEqual([[], [], [], []], self.caught_entries)
2573
self.assertEqual([[], []], self.caught_entries)
1362
2574
1363
2575
def test_add_versions_different_dup(self):
1364
2576
index = self.two_graph_index(catch_adds=True)
1365
2577
# change options
1366
self.assertRaises(errors.KnitCorrupt, index.add_records,
1367
[(('tip',), 'no-eol,line-delta', (None, 0, 100), [])])
1368
self.assertRaises(errors.KnitCorrupt, index.add_records,
1369
[(('tip',), 'line-delta,no-eol', (None, 0, 100), [])])
1370
self.assertRaises(errors.KnitCorrupt, index.add_records,
1371
[(('tip',), 'fulltext', (None, 0, 100), [])])
2578
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2579
[('tip', 'no-eol,line-delta', (None, 0, 100), [])])
2580
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2581
[('tip', 'line-delta,no-eol', (None, 0, 100), [])])
2582
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2583
[('tip', 'fulltext', (None, 0, 100), [])])
2584
# position/length
2585
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2586
[('tip', 'fulltext,no-eol', (None, 50, 100), [])])
2587
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2588
[('tip', 'fulltext,no-eol', (None, 0, 1000), [])])
1372
2589
# parents
1373
self.assertRaises(errors.KnitCorrupt, index.add_records,
1374
[(('tip',), 'fulltext,no-eol', (None, 0, 100), [('parent',)])])
2590
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2591
[('tip', 'fulltext,no-eol', (None, 0, 100), ['parent'])])
1375
2592
# change options in the second record
1376
self.assertRaises(errors.KnitCorrupt, index.add_records,
1377
[(('tip',), 'fulltext,no-eol', (None, 0, 100), []),
1378
(('tip',), 'no-eol,line-delta', (None, 0, 100), [])])
2593
self.assertRaises(errors.KnitCorrupt, index.add_versions,
2594
[('tip', 'fulltext,no-eol', (None, 0, 100), []),
2595
('tip', 'no-eol,line-delta', (None, 0, 100), [])])
1379
2596
self.assertEqual([], self.caught_entries)
1380
2597
1381
1382
class TestStacking(KnitTests):
1383
1384
def get_basis_and_test_knit(self):
1385
basis = self.make_test_knit(name='basis')
1386
basis = RecordingVersionedFilesDecorator(basis)
1387
test = self.make_test_knit(name='test')
1388
test.add_fallback_versioned_files(basis)
1389
return basis, test
1390
1391
def test_add_fallback_versioned_files(self):
1392
basis = self.make_test_knit(name='basis')
1393
test = self.make_test_knit(name='test')
1394
# It must not error; other tests test that the fallback is referred to
1395
# when accessing data.
1396
test.add_fallback_versioned_files(basis)
1397
1398
def test_add_lines(self):
1399
# lines added to the test are not added to the basis
1400
basis, test = self.get_basis_and_test_knit()
1401
key = ('foo',)
1402
key_basis = ('bar',)
1403
key_cross_border = ('quux',)
1404
key_delta = ('zaphod',)
1405
test.add_lines(key, (), ['foo\n'])
1406
self.assertEqual({}, basis.get_parent_map([key]))
1407
# lines added to the test that reference across the stack do a
1408
# fulltext.
1409
basis.add_lines(key_basis, (), ['foo\n'])
1410
basis.calls = []
1411
test.add_lines(key_cross_border, (key_basis,), ['foo\n'])
1412
self.assertEqual('fulltext', test._index.get_method(key_cross_border))
1413
self.assertEqual([("get_parent_map", set([key_basis]))], basis.calls)
1414
# Subsequent adds do delta.
1415
basis.calls = []
1416
test.add_lines(key_delta, (key_cross_border,), ['foo\n'])
1417
self.assertEqual('line-delta', test._index.get_method(key_delta))
1418
self.assertEqual([], basis.calls)
1419
1420
def test_annotate(self):
1421
# annotations from the test knit are answered without asking the basis
1422
basis, test = self.get_basis_and_test_knit()
1423
key = ('foo',)
1424
key_basis = ('bar',)
1425
key_missing = ('missing',)
1426
test.add_lines(key, (), ['foo\n'])
1427
details = test.annotate(key)
1428
self.assertEqual([(key, 'foo\n')], details)
1429
self.assertEqual([], basis.calls)
1430
# But texts that are not in the test knit are looked for in the basis
1431
# directly.
1432
basis.add_lines(key_basis, (), ['foo\n', 'bar\n'])
1433
basis.calls = []
1434
details = test.annotate(key_basis)
1435
self.assertEqual([(key_basis, 'foo\n'), (key_basis, 'bar\n')], details)
1436
# Not optimised to date:
1437
# self.assertEqual([("annotate", key_basis)], basis.calls)
1438
self.assertEqual([('get_parent_map', set([key_basis])),
1439
('get_parent_map', set([key_basis])),
1440
('get_parent_map', set([key_basis])),
1441
('get_record_stream', [key_basis], 'unordered', True)],
1442
basis.calls)
1443
1444
def test_check(self):
1445
# At the moment checking a stacked knit does implicitly check the
1446
# fallback files.
1447
basis, test = self.get_basis_and_test_knit()
1448
test.check()
1449
1450
def test_get_parent_map(self):
1451
# parents in the test knit are answered without asking the basis
1452
basis, test = self.get_basis_and_test_knit()
1453
key = ('foo',)
1454
key_basis = ('bar',)
1455
key_missing = ('missing',)
1456
test.add_lines(key, (), [])
1457
parent_map = test.get_parent_map([key])
1458
self.assertEqual({key: ()}, parent_map)
1459
self.assertEqual([], basis.calls)
1460
# But parents that are not in the test knit are looked for in the basis
1461
basis.add_lines(key_basis, (), [])
1462
basis.calls = []
1463
parent_map = test.get_parent_map([key, key_basis, key_missing])
1464
self.assertEqual({key: (),
1465
key_basis: ()}, parent_map)
1466
self.assertEqual([("get_parent_map", set([key_basis, key_missing]))],
1467
basis.calls)
1468
1469
def test_get_record_stream_unordered_fulltexts(self):
1470
# records from the test knit are answered without asking the basis:
1471
basis, test = self.get_basis_and_test_knit()
1472
key = ('foo',)
1473
key_basis = ('bar',)
1474
key_missing = ('missing',)
1475
test.add_lines(key, (), ['foo\n'])
1476
records = list(test.get_record_stream([key], 'unordered', True))
1477
self.assertEqual(1, len(records))
1478
self.assertEqual([], basis.calls)
1479
# Missing (from test knit) objects are retrieved from the basis:
1480
basis.add_lines(key_basis, (), ['foo\n', 'bar\n'])
1481
basis.calls = []
1482
records = list(test.get_record_stream([key_basis, key_missing],
1483
'unordered', True))
1484
self.assertEqual(2, len(records))
1485
calls = list(basis.calls)
1486
for record in records:
1487
self.assertSubset([record.key], (key_basis, key_missing))
1488
if record.key == key_missing:
1489
self.assertIsInstance(record, AbsentContentFactory)
1490
else:
1491
reference = list(basis.get_record_stream([key_basis],
1492
'unordered', True))[0]
1493
self.assertEqual(reference.key, record.key)
1494
self.assertEqual(reference.sha1, record.sha1)
1495
self.assertEqual(reference.storage_kind, record.storage_kind)
1496
self.assertEqual(reference.get_bytes_as(reference.storage_kind),
1497
record.get_bytes_as(record.storage_kind))
1498
self.assertEqual(reference.get_bytes_as('fulltext'),
1499
record.get_bytes_as('fulltext'))
1500
# It's not strictly minimal, but it seems reasonable for now for it to
1501
# ask which fallbacks have which parents.
1502
self.assertEqual([
1503
("get_parent_map", set([key_basis, key_missing])),
1504
("get_record_stream", [key_basis], 'unordered', True)],
1505
calls)
1506
1507
def test_get_record_stream_ordered_fulltexts(self):
1508
# ordering is preserved down into the fallback store.
1509
basis, test = self.get_basis_and_test_knit()
1510
key = ('foo',)
1511
key_basis = ('bar',)
1512
key_basis_2 = ('quux',)
1513
key_missing = ('missing',)
1514
test.add_lines(key, (key_basis,), ['foo\n'])
1515
# Missing (from test knit) objects are retrieved from the basis:
1516
basis.add_lines(key_basis, (key_basis_2,), ['foo\n', 'bar\n'])
1517
basis.add_lines(key_basis_2, (), ['quux\n'])
1518
basis.calls = []
1519
# ask for in non-topological order
1520
records = list(test.get_record_stream(
1521
[key, key_basis, key_missing, key_basis_2], 'topological', True))
1522
self.assertEqual(4, len(records))
1523
results = []
1524
for record in records:
1525
self.assertSubset([record.key],
1526
(key_basis, key_missing, key_basis_2, key))
1527
if record.key == key_missing:
1528
self.assertIsInstance(record, AbsentContentFactory)
1529
else:
1530
results.append((record.key, record.sha1, record.storage_kind,
1531
record.get_bytes_as('fulltext')))
1532
calls = list(basis.calls)
1533
order = [record[0] for record in results]
1534
self.assertEqual([key_basis_2, key_basis, key], order)
1535
for result in results:
1536
if result[0] == key:
1537
source = test
1538
else:
1539
source = basis
1540
record = source.get_record_stream([result[0]], 'unordered',
1541
True).next()
1542
self.assertEqual(record.key, result[0])
1543
self.assertEqual(record.sha1, result[1])
1544
self.assertEqual(record.storage_kind, result[2])
1545
self.assertEqual(record.get_bytes_as('fulltext'), result[3])
1546
# It's not strictly minimal, but it seems reasonable for now for it to
1547
# ask which fallbacks have which parents.
1548
self.assertEqual([
1549
("get_parent_map", set([key_basis, key_basis_2, key_missing])),
1550
# unordered is asked for by the underlying worker as it still
1551
# buffers everything while answering - which is a problem!
1552
("get_record_stream", [key_basis_2, key_basis], 'unordered', True)],
1553
calls)
1554
1555
def test_get_record_stream_unordered_deltas(self):
1556
# records from the test knit are answered without asking the basis:
1557
basis, test = self.get_basis_and_test_knit()
1558
key = ('foo',)
1559
key_basis = ('bar',)
1560
key_missing = ('missing',)
1561
test.add_lines(key, (), ['foo\n'])
1562
records = list(test.get_record_stream([key], 'unordered', False))
1563
self.assertEqual(1, len(records))
1564
self.assertEqual([], basis.calls)
1565
# Missing (from test knit) objects are retrieved from the basis:
1566
basis.add_lines(key_basis, (), ['foo\n', 'bar\n'])
1567
basis.calls = []
1568
records = list(test.get_record_stream([key_basis, key_missing],
1569
'unordered', False))
1570
self.assertEqual(2, len(records))
1571
calls = list(basis.calls)
1572
for record in records:
1573
self.assertSubset([record.key], (key_basis, key_missing))
1574
if record.key == key_missing:
1575
self.assertIsInstance(record, AbsentContentFactory)
1576
else:
1577
reference = list(basis.get_record_stream([key_basis],
1578
'unordered', False))[0]
1579
self.assertEqual(reference.key, record.key)
1580
self.assertEqual(reference.sha1, record.sha1)
1581
self.assertEqual(reference.storage_kind, record.storage_kind)
1582
self.assertEqual(reference.get_bytes_as(reference.storage_kind),
1583
record.get_bytes_as(record.storage_kind))
1584
# It's not strictly minimal, but it seems reasonable for now for it to
1585
# ask which fallbacks have which parents.
1586
self.assertEqual([
1587
("get_parent_map", set([key_basis, key_missing])),
1588
("get_record_stream", [key_basis], 'unordered', False)],
1589
calls)
1590
1591
def test_get_record_stream_ordered_deltas(self):
1592
# ordering is preserved down into the fallback store.
1593
basis, test = self.get_basis_and_test_knit()
1594
key = ('foo',)
1595
key_basis = ('bar',)
1596
key_basis_2 = ('quux',)
1597
key_missing = ('missing',)
1598
test.add_lines(key, (key_basis,), ['foo\n'])
1599
# Missing (from test knit) objects are retrieved from the basis:
1600
basis.add_lines(key_basis, (key_basis_2,), ['foo\n', 'bar\n'])
1601
basis.add_lines(key_basis_2, (), ['quux\n'])
1602
basis.calls = []
1603
# ask for in non-topological order
1604
records = list(test.get_record_stream(
1605
[key, key_basis, key_missing, key_basis_2], 'topological', False))
1606
self.assertEqual(4, len(records))
1607
results = []
1608
for record in records:
1609
self.assertSubset([record.key],
1610
(key_basis, key_missing, key_basis_2, key))
1611
if record.key == key_missing:
1612
self.assertIsInstance(record, AbsentContentFactory)
1613
else:
1614
results.append((record.key, record.sha1, record.storage_kind,
1615
record.get_bytes_as(record.storage_kind)))
1616
calls = list(basis.calls)
1617
order = [record[0] for record in results]
1618
self.assertEqual([key_basis_2, key_basis, key], order)
1619
for result in results:
1620
if result[0] == key:
1621
source = test
1622
else:
1623
source = basis
1624
record = source.get_record_stream([result[0]], 'unordered',
1625
False).next()
1626
self.assertEqual(record.key, result[0])
1627
self.assertEqual(record.sha1, result[1])
1628
self.assertEqual(record.storage_kind, result[2])
1629
self.assertEqual(record.get_bytes_as(record.storage_kind), result[3])
1630
# It's not strictly minimal, but it seems reasonable for now for it to
1631
# ask which fallbacks have which parents.
1632
self.assertEqual([
1633
("get_parent_map", set([key_basis, key_basis_2, key_missing])),
1634
("get_record_stream", [key_basis_2, key_basis], 'topological', False)],
1635
calls)
1636
1637
def test_get_sha1s(self):
1638
# sha1's in the test knit are answered without asking the basis
1639
basis, test = self.get_basis_and_test_knit()
1640
key = ('foo',)
1641
key_basis = ('bar',)
1642
key_missing = ('missing',)
1643
test.add_lines(key, (), ['foo\n'])
1644
key_sha1sum = sha.new('foo\n').hexdigest()
1645
sha1s = test.get_sha1s([key])
1646
self.assertEqual({key: key_sha1sum}, sha1s)
1647
self.assertEqual([], basis.calls)
1648
# But texts that are not in the test knit are looked for in the basis
1649
# directly (rather than via text reconstruction) so that remote servers
1650
# etc don't have to answer with full content.
1651
basis.add_lines(key_basis, (), ['foo\n', 'bar\n'])
1652
basis_sha1sum = sha.new('foo\nbar\n').hexdigest()
1653
basis.calls = []
1654
sha1s = test.get_sha1s([key, key_missing, key_basis])
1655
self.assertEqual({key: key_sha1sum,
1656
key_basis: basis_sha1sum}, sha1s)
1657
self.assertEqual([("get_sha1s", set([key_basis, key_missing]))],
1658
basis.calls)
1659
1660
def test_insert_record_stream(self):
1661
# records are inserted as normal; insert_record_stream builds on
1662
# add_lines, so a smoke test should be all that's needed:
1663
key = ('foo',)
1664
key_basis = ('bar',)
1665
key_delta = ('zaphod',)
1666
basis, test = self.get_basis_and_test_knit()
1667
source = self.make_test_knit(name='source')
1668
basis.add_lines(key_basis, (), ['foo\n'])
1669
basis.calls = []
1670
source.add_lines(key_basis, (), ['foo\n'])
1671
source.add_lines(key_delta, (key_basis,), ['bar\n'])
1672
stream = source.get_record_stream([key_delta], 'unordered', False)
1673
test.insert_record_stream(stream)
1674
self.assertEqual([("get_parent_map", set([key_basis]))],
1675
basis.calls)
1676
self.assertEqual({key_delta:(key_basis,)},
1677
test.get_parent_map([key_delta]))
1678
self.assertEqual('bar\n', test.get_record_stream([key_delta],
1679
'unordered', True).next().get_bytes_as('fulltext'))
1680
1681
def test_iter_lines_added_or_present_in_keys(self):
1682
# Lines from the basis are returned, and lines for a given key are only
1683
# returned once.
1684
key1 = ('foo1',)
1685
key2 = ('foo2',)
1686
# all sources are asked for keys:
1687
basis, test = self.get_basis_and_test_knit()
1688
basis.add_lines(key1, (), ["foo"])
1689
basis.calls = []
1690
lines = list(test.iter_lines_added_or_present_in_keys([key1]))
1691
self.assertEqual([("foo\n", key1)], lines)
1692
self.assertEqual([("iter_lines_added_or_present_in_keys", set([key1]))],
1693
basis.calls)
1694
# keys in both are not duplicated:
1695
test.add_lines(key2, (), ["bar\n"])
1696
basis.add_lines(key2, (), ["bar\n"])
1697
basis.calls = []
1698
lines = list(test.iter_lines_added_or_present_in_keys([key2]))
1699
self.assertEqual([("bar\n", key2)], lines)
1700
self.assertEqual([], basis.calls)
1701
1702
def test_keys(self):
1703
key1 = ('foo1',)
1704
key2 = ('foo2',)
1705
# all sources are asked for keys:
1706
basis, test = self.get_basis_and_test_knit()
1707
keys = test.keys()
1708
self.assertEqual(set(), set(keys))
1709
self.assertEqual([("keys",)], basis.calls)
1710
# keys from a basis are returned:
1711
basis.add_lines(key1, (), [])
1712
basis.calls = []
1713
keys = test.keys()
1714
self.assertEqual(set([key1]), set(keys))
1715
self.assertEqual([("keys",)], basis.calls)
1716
# keys in both are not duplicated:
1717
test.add_lines(key2, (), [])
1718
basis.add_lines(key2, (), [])
1719
basis.calls = []
1720
keys = test.keys()
1721
self.assertEqual(2, len(keys))
1722
self.assertEqual(set([key1, key2]), set(keys))
1723
self.assertEqual([("keys",)], basis.calls)
1724
1725
def test_add_mpdiffs(self):
1726
# records are inserted as normal; add_mpdiff builds on
1727
# add_lines, so a smoke test should be all that's needed:
1728
key = ('foo',)
1729
key_basis = ('bar',)
1730
key_delta = ('zaphod',)
1731
basis, test = self.get_basis_and_test_knit()
1732
source = self.make_test_knit(name='source')
1733
basis.add_lines(key_basis, (), ['foo\n'])
1734
basis.calls = []
1735
source.add_lines(key_basis, (), ['foo\n'])
1736
source.add_lines(key_delta, (key_basis,), ['bar\n'])
1737
diffs = source.make_mpdiffs([key_delta])
1738
test.add_mpdiffs([(key_delta, (key_basis,),
1739
source.get_sha1s([key_delta])[key_delta], diffs[0])])
1740
self.assertEqual([("get_parent_map", set([key_basis])),
1741
('get_record_stream', [key_basis], 'unordered', True),
1742
('get_parent_map', set([key_basis]))],
1743
basis.calls)
1744
self.assertEqual({key_delta:(key_basis,)},
1745
test.get_parent_map([key_delta]))
1746
self.assertEqual('bar\n', test.get_record_stream([key_delta],
1747
'unordered', True).next().get_bytes_as('fulltext'))
1748
1749
def test_make_mpdiffs(self):
1750
# Generating an mpdiff across a stacking boundary should detect parent
1751
# texts regions.
1752
key = ('foo',)
1753
key_left = ('bar',)
1754
key_right = ('zaphod',)
1755
basis, test = self.get_basis_and_test_knit()
1756
basis.add_lines(key_left, (), ['bar\n'])
1757
basis.add_lines(key_right, (), ['zaphod\n'])
1758
basis.calls = []
1759
test.add_lines(key, (key_left, key_right),
1760
['bar\n', 'foo\n', 'zaphod\n'])
1761
diffs = test.make_mpdiffs([key])
1762
self.assertEqual([
1763
multiparent.MultiParent([multiparent.ParentText(0, 0, 0, 1),
1764
multiparent.NewText(['foo\n']),
1765
multiparent.ParentText(1, 0, 2, 1)])],
1766
diffs)
1767
self.assertEqual(4, len(basis.calls))
1768
self.assertEqual([
1769
("get_parent_map", set([key_left, key_right])),
1770
("get_parent_map", set([key_left, key_right])),
1771
("get_parent_map", set([key_left, key_right])),
1772
],
1773
basis.calls[:3])
1774
last_call = basis.calls[3]
1775
self.assertEqual('get_record_stream', last_call[0])
1776
self.assertEqual(set([key_left, key_right]), set(last_call[1]))
1777
self.assertEqual('unordered', last_call[2])
1778
self.assertEqual(True, last_call[3])
2598
class TestPackKnits(KnitTests):
2599
"""Tests that use a _PackAccess and KnitGraphIndex."""
2600
2601
def test_get_data_stream_packs_ignores_pack_overhead(self):
2602
# Packs have an encoding overhead that should not be included in the
2603
# 'size' field of a data stream, because it is not returned by the
2604
# raw_reading functions - it is why index_memo's are opaque, and
2605
# get_data_stream was abusing this.
2606
packname = 'test.pack'
2607
transport = self.get_transport()
2608
def write_data(bytes):
2609
transport.append_bytes(packname, bytes)
2610
writer = pack.ContainerWriter(write_data)
2611
writer.begin()
2612
index = InMemoryGraphIndex(2)
2613
knit_index = KnitGraphIndex(index, add_callback=index.add_nodes,
2614
deltas=True)
2615
indices = {index:(transport, packname)}
2616
access = _PackAccess(indices, writer=(writer, index))
2617
k = KnitVersionedFile('test', get_transport('.'),
2618
delta=True, create=True, index=knit_index, access_method=access)
2619
# insert something into the knit
2620
k.add_lines('text-1', [], ["foo\n"])
2621
# get a data stream for it
2622
stream = k.get_data_stream(['text-1'])
2623
# if the stream has been incorrectly assembled, we will get a short read
2624
# reading from the stream (as streams have no trailer)
2625
expected_length = stream[1][0][2]
2626
# we use -1 to do the read, so that if a trailer is added this test
2627
# will fail and we'll adjust it to handle that case correctly, rather
2628
# than allowing an over-read that is bogus.
2629
self.assertEqual(expected_length, len(stream[2](-1)))
2630
2631
2632
class Test_StreamIndex(KnitTests):
2633
2634
def get_index(self, knit, stream):
2635
"""Get a _StreamIndex from knit and stream."""
2636
return knit._knit_from_datastream(stream)._index
2637
2638
def assertIndexVersions(self, knit, versions):
2639
"""Check that the _StreamIndex versions are those of the stream."""
2640
index = self.get_index(knit, knit.get_data_stream(versions))
2641
self.assertEqual(set(index.get_versions()), set(versions))
2642
# check we didn't get duplicates
2643
self.assertEqual(len(index.get_versions()), len(versions))
2644
2645
def assertIndexAncestry(self, knit, ancestry_versions, versions, result):
2646
"""Check the result of a get_ancestry call on knit."""
2647
index = self.get_index(knit, knit.get_data_stream(versions))
2648
self.assertEqual(
2649
set(result),
2650
set(index.get_ancestry(ancestry_versions, False)))
2651
2652
def assertGetMethod(self, knit, versions, version, result):
2653
index = self.get_index(knit, knit.get_data_stream(versions))
2654
self.assertEqual(result, index.get_method(version))
2655
2656
def assertGetOptions(self, knit, version, options):
2657
index = self.get_index(knit, knit.get_data_stream(version))
2658
self.assertEqual(options, index.get_options(version))
2659
2660
def assertGetPosition(self, knit, versions, version, result):
2661
index = self.get_index(knit, knit.get_data_stream(versions))
2662
if result[1] is None:
2663
result = (result[0], index, result[2], result[3])
2664
self.assertEqual(result, index.get_position(version))
2665
2666
def assertGetParentsWithGhosts(self, knit, versions, version, parents):
2667
index = self.get_index(knit, knit.get_data_stream(versions))
2668
self.assertEqual(parents, index.get_parents_with_ghosts(version))
2669
2670
def make_knit_with_4_versions_2_dags(self):
2671
knit = self.make_test_knit()
2672
knit.add_lines('a', [], ["foo"])
2673
knit.add_lines('b', [], [])
2674
knit.add_lines('c', ['b', 'a'], [])
2675
knit.add_lines_with_ghosts('d', ['e', 'f'], [])
2676
return knit
2677
2678
def test_versions(self):
2679
"""The versions of a StreamIndex are those of the datastream."""
2680
knit = self.make_knit_with_4_versions_2_dags()
2681
# ask for most permutations, which catches bugs like falling back to the
2682
# target knit, or showing ghosts, etc.
2683
self.assertIndexVersions(knit, [])
2684
self.assertIndexVersions(knit, ['a'])
2685
self.assertIndexVersions(knit, ['b'])
2686
self.assertIndexVersions(knit, ['c'])
2687
self.assertIndexVersions(knit, ['d'])
2688
self.assertIndexVersions(knit, ['a', 'b'])
2689
self.assertIndexVersions(knit, ['b', 'c'])
2690
self.assertIndexVersions(knit, ['a', 'c'])
2691
self.assertIndexVersions(knit, ['a', 'b', 'c'])
2692
self.assertIndexVersions(knit, ['a', 'b', 'c', 'd'])
2693
2694
def test_construct(self):
2695
"""Constructing a StreamIndex generates index data."""
2696
data_list = [('text-a', ['fulltext'], 127, []),
2697
('text-b', ['option'], 128, ['text-c'])]
2698
index = _StreamIndex(data_list, None)
2699
self.assertEqual({'text-a':(['fulltext'], (0, 127), []),
2700
'text-b':(['option'], (127, 127 + 128), ['text-c'])},
2701
index._by_version)
2702
2703
def test_get_ancestry(self):
2704
knit = self.make_knit_with_4_versions_2_dags()
2705
self.assertIndexAncestry(knit, ['a'], ['a'], ['a'])
2706
self.assertIndexAncestry(knit, ['b'], ['b'], ['b'])
2707
self.assertIndexAncestry(knit, ['c'], ['c'], ['c'])
2708
self.assertIndexAncestry(knit, ['c'], ['a', 'b', 'c'],
2709
set(['a', 'b', 'c']))
2710
self.assertIndexAncestry(knit, ['c', 'd'], ['a', 'b', 'c', 'd'],
2711
set(['a', 'b', 'c', 'd']))
2712
2713
def test_get_method(self):
2714
knit = self.make_knit_with_4_versions_2_dags()
2715
self.assertGetMethod(knit, ['a'], 'a', 'fulltext')
2716
self.assertGetMethod(knit, ['c'], 'c', 'line-delta')
2717
# get_method on a basis that is not in the datastream (but in the
2718
# backing knit) returns 'fulltext', because thats what we'll create as
2719
# we thunk across.
2720
self.assertGetMethod(knit, ['c'], 'b', 'fulltext')
2721
2722
def test_get_options(self):
2723
knit = self.make_knit_with_4_versions_2_dags()
2724
self.assertGetOptions(knit, 'a', ['no-eol', 'fulltext'])
2725
self.assertGetOptions(knit, 'c', ['line-delta'])
2726
2727
def test_get_parents_with_ghosts(self):
2728
knit = self.make_knit_with_4_versions_2_dags()
2729
self.assertGetParentsWithGhosts(knit, ['a'], 'a', ())
2730
self.assertGetParentsWithGhosts(knit, ['c'], 'c', ('b', 'a'))
2731
self.assertGetParentsWithGhosts(knit, ['d'], 'd', ('e', 'f'))
2732
2733
def test_get_position(self):
2734
knit = self.make_knit_with_4_versions_2_dags()
2735
# get_position returns (thunk_flag, index(can be None), start, end) for
2736
# _StreamAccess to use.
2737
self.assertGetPosition(knit, ['a'], 'a', (False, None, 0, 78))
2738
self.assertGetPosition(knit, ['a', 'c'], 'c', (False, None, 78, 156))
2739
# get_position on a text that is not in the datastream (but in the
2740
# backing knit) returns (True, 'versionid', None, None) - and then the
2741
# access object can construct the relevant data as needed.
2742
self.assertGetPosition(knit, ['a', 'c'], 'b', (True, 'b', None, None))
2743
2744
2745
class Test_StreamAccess(KnitTests):
2746
2747
def get_index_access(self, knit, stream):
2748
"""Get a _StreamAccess from knit and stream."""
2749
knit = knit._knit_from_datastream(stream)
2750
return knit._index, knit._data._access
2751
2752
def assertGetRawRecords(self, knit, versions):
2753
index, access = self.get_index_access(knit,
2754
knit.get_data_stream(versions))
2755
# check that every version asked for can be obtained from the resulting
2756
# access object.
2757
# batch
2758
memos = []
2759
for version in versions:
2760
memos.append(knit._index.get_position(version))
2761
original = {}
2762
for version, data in zip(
2763
versions, knit._data._access.get_raw_records(memos)):
2764
original[version] = data
2765
memos = []
2766
for version in versions:
2767
memos.append(index.get_position(version))
2768
streamed = {}
2769
for version, data in zip(versions, access.get_raw_records(memos)):
2770
streamed[version] = data
2771
self.assertEqual(original, streamed)
2772
# individually
2773
for version in versions:
2774
data = list(access.get_raw_records(
2775
[index.get_position(version)]))[0]
2776
self.assertEqual(original[version], data)
2777
2778
def make_knit_with_two_versions(self):
2779
knit = self.make_test_knit()
2780
knit.add_lines('a', [], ["foo"])
2781
knit.add_lines('b', [], ["bar"])
2782
return knit
2783
2784
def test_get_raw_records(self):
2785
knit = self.make_knit_with_two_versions()
2786
self.assertGetRawRecords(knit, ['a', 'b'])
2787
self.assertGetRawRecords(knit, ['a'])
2788
self.assertGetRawRecords(knit, ['b'])
2789
2790
def test_get_raw_record_from_backing_knit(self):
2791
# the thunk layer should create an artificial A on-demand when needed.
2792
source_knit = self.make_test_knit(name='plain', annotate=False)
2793
target_knit = self.make_test_knit(name='annotated', annotate=True)
2794
source_knit.add_lines("A", [], ["Foo\n"])
2795
# Give the target A, so we can try to thunk across to it.
2796
target_knit.join(source_knit)
2797
index, access = self.get_index_access(target_knit,
2798
source_knit.get_data_stream([]))
2799
raw_data = list(access.get_raw_records([(True, "A", None, None)]))[0]
2800
df = GzipFile(mode='rb', fileobj=StringIO(raw_data))
2801
self.assertEqual(
2802
'version A 1 5d36b88bb697a2d778f024048bafabd443d74503\n'
2803
'Foo\nend A\n',
2804
df.read())
2805
2806
def test_asking_for_thunk_stream_is_not_plain_errors(self):
2807
knit = self.make_test_knit(name='annotated', annotate=True)
2808
knit.add_lines("A", [], ["Foo\n"])
2809
index, access = self.get_index_access(knit,
2810
knit.get_data_stream([]))
2811
self.assertRaises(errors.KnitCorrupt,
2812
list, access.get_raw_records([(True, "A", None, None)]))
2813
2814
2815
class TestFormatSignatures(KnitTests):
2816
2817
def test_knit_format_signatures(self):
2818
"""Different formats of knit have different signature strings."""
2819
knit = self.make_test_knit(name='a', annotate=True)
2820
self.assertEqual('knit-annotated', knit.get_format_signature())
2821
knit = self.make_test_knit(name='p', annotate=False)
2822
self.assertEqual('knit-plain', knit.get_format_signature())
Loggerhead is a web-based interface for Breezy
Version: 2.0.1