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