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