~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_knit.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-10-10 07:23:07 UTC
  • mfrom: (2067.1.1 urandom-56883)
  • Revision ID: pqm@pqm.ubuntu.com-20061010072307-037a6f63da8a1bdd
(John Arbash Meinel) Handle exceptions while opening /dev/urandom

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 by Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Tests for Knit data structure"""
18
18
 
19
 
from cStringIO import StringIO
 
19
 
20
20
import difflib
21
 
import gzip
22
 
import sha
23
 
import sys
24
 
 
25
 
from bzrlib import (
26
 
    errors,
27
 
    generate_ids,
28
 
    knit,
29
 
    )
30
 
from bzrlib.errors import (
31
 
    RevisionAlreadyPresent,
32
 
    KnitHeaderError,
33
 
    RevisionNotPresent,
34
 
    NoSuchFile,
35
 
    )
 
21
 
 
22
 
 
23
from bzrlib.errors import KnitError, RevisionAlreadyPresent, NoSuchFile
36
24
from bzrlib.knit import (
37
 
    KnitContent,
38
25
    KnitVersionedFile,
39
26
    KnitPlainFactory,
40
27
    KnitAnnotateFactory,
41
 
    _KnitData,
42
 
    _KnitIndex,
43
 
    WeaveToKnit,
44
 
    )
 
28
    WeaveToKnit)
45
29
from bzrlib.osutils import split_lines
46
 
from bzrlib.tests import TestCase, TestCaseWithTransport, Feature
 
30
from bzrlib.tests import TestCaseWithTransport
47
31
from bzrlib.transport import TransportLogger, get_transport
48
32
from bzrlib.transport.memory import MemoryTransport
49
33
from bzrlib.weave import Weave
50
34
 
51
35
 
52
 
class _CompiledKnitFeature(Feature):
53
 
 
54
 
    def _probe(self):
55
 
        try:
56
 
            import bzrlib._knit_load_data_c
57
 
        except ImportError:
58
 
            return False
59
 
        return True
60
 
 
61
 
    def feature_name(self):
62
 
        return 'bzrlib._knit_load_data_c'
63
 
 
64
 
CompiledKnitFeature = _CompiledKnitFeature()
65
 
 
66
 
 
67
 
class KnitContentTests(TestCase):
68
 
 
69
 
    def test_constructor(self):
70
 
        content = KnitContent([])
71
 
 
72
 
    def test_text(self):
73
 
        content = KnitContent([])
74
 
        self.assertEqual(content.text(), [])
75
 
 
76
 
        content = KnitContent([("origin1", "text1"), ("origin2", "text2")])
77
 
        self.assertEqual(content.text(), ["text1", "text2"])
78
 
 
79
 
    def test_annotate(self):
80
 
        content = KnitContent([])
81
 
        self.assertEqual(content.annotate(), [])
82
 
 
83
 
        content = KnitContent([("origin1", "text1"), ("origin2", "text2")])
84
 
        self.assertEqual(content.annotate(),
85
 
            [("origin1", "text1"), ("origin2", "text2")])
86
 
 
87
 
    def test_annotate_iter(self):
88
 
        content = KnitContent([])
89
 
        it = content.annotate_iter()
90
 
        self.assertRaises(StopIteration, it.next)
91
 
 
92
 
        content = KnitContent([("origin1", "text1"), ("origin2", "text2")])
93
 
        it = content.annotate_iter()
94
 
        self.assertEqual(it.next(), ("origin1", "text1"))
95
 
        self.assertEqual(it.next(), ("origin2", "text2"))
96
 
        self.assertRaises(StopIteration, it.next)
97
 
 
98
 
    def test_copy(self):
99
 
        content = KnitContent([("origin1", "text1"), ("origin2", "text2")])
100
 
        copy = content.copy()
101
 
        self.assertIsInstance(copy, KnitContent)
102
 
        self.assertEqual(copy.annotate(),
103
 
            [("origin1", "text1"), ("origin2", "text2")])
104
 
 
105
 
    def test_line_delta(self):
106
 
        content1 = KnitContent([("", "a"), ("", "b")])
107
 
        content2 = KnitContent([("", "a"), ("", "a"), ("", "c")])
108
 
        self.assertEqual(content1.line_delta(content2),
109
 
            [(1, 2, 2, [("", "a"), ("", "c")])])
110
 
 
111
 
    def test_line_delta_iter(self):
112
 
        content1 = KnitContent([("", "a"), ("", "b")])
113
 
        content2 = KnitContent([("", "a"), ("", "a"), ("", "c")])
114
 
        it = content1.line_delta_iter(content2)
115
 
        self.assertEqual(it.next(), (1, 2, 2, [("", "a"), ("", "c")]))
116
 
        self.assertRaises(StopIteration, it.next)
117
 
 
118
 
 
119
 
class MockTransport(object):
120
 
 
121
 
    def __init__(self, file_lines=None):
122
 
        self.file_lines = file_lines
123
 
        self.calls = []
124
 
        # We have no base directory for the MockTransport
125
 
        self.base = ''
126
 
 
127
 
    def get(self, filename):
128
 
        if self.file_lines is None:
129
 
            raise NoSuchFile(filename)
130
 
        else:
131
 
            return StringIO("\n".join(self.file_lines))
132
 
 
133
 
    def readv(self, relpath, offsets):
134
 
        fp = self.get(relpath)
135
 
        for offset, size in offsets:
136
 
            fp.seek(offset)
137
 
            yield offset, fp.read(size)
138
 
 
139
 
    def __getattr__(self, name):
140
 
        def queue_call(*args, **kwargs):
141
 
            self.calls.append((name, args, kwargs))
142
 
        return queue_call
143
 
 
144
 
 
145
 
class LowLevelKnitDataTests(TestCase):
146
 
 
147
 
    def create_gz_content(self, text):
148
 
        sio = StringIO()
149
 
        gz_file = gzip.GzipFile(mode='wb', fileobj=sio)
150
 
        gz_file.write(text)
151
 
        gz_file.close()
152
 
        return sio.getvalue()
153
 
 
154
 
    def test_valid_knit_data(self):
155
 
        sha1sum = sha.new('foo\nbar\n').hexdigest()
156
 
        gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'
157
 
                                        'foo\n'
158
 
                                        'bar\n'
159
 
                                        'end rev-id-1\n'
160
 
                                        % (sha1sum,))
161
 
        transport = MockTransport([gz_txt])
162
 
        data = _KnitData(transport, 'filename', mode='r')
163
 
        records = [('rev-id-1', 0, len(gz_txt))]
164
 
 
165
 
        contents = data.read_records(records)
166
 
        self.assertEqual({'rev-id-1':(['foo\n', 'bar\n'], sha1sum)}, contents)
167
 
 
168
 
        raw_contents = list(data.read_records_iter_raw(records))
169
 
        self.assertEqual([('rev-id-1', gz_txt)], raw_contents)
170
 
 
171
 
    def test_not_enough_lines(self):
172
 
        sha1sum = sha.new('foo\n').hexdigest()
173
 
        # record says 2 lines data says 1
174
 
        gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'
175
 
                                        'foo\n'
176
 
                                        'end rev-id-1\n'
177
 
                                        % (sha1sum,))
178
 
        transport = MockTransport([gz_txt])
179
 
        data = _KnitData(transport, 'filename', mode='r')
180
 
        records = [('rev-id-1', 0, len(gz_txt))]
181
 
        self.assertRaises(errors.KnitCorrupt, data.read_records, records)
182
 
 
183
 
        # read_records_iter_raw won't detect that sort of mismatch/corruption
184
 
        raw_contents = list(data.read_records_iter_raw(records))
185
 
        self.assertEqual([('rev-id-1', gz_txt)], raw_contents)
186
 
 
187
 
    def test_too_many_lines(self):
188
 
        sha1sum = sha.new('foo\nbar\n').hexdigest()
189
 
        # record says 1 lines data says 2
190
 
        gz_txt = self.create_gz_content('version rev-id-1 1 %s\n'
191
 
                                        'foo\n'
192
 
                                        'bar\n'
193
 
                                        'end rev-id-1\n'
194
 
                                        % (sha1sum,))
195
 
        transport = MockTransport([gz_txt])
196
 
        data = _KnitData(transport, 'filename', mode='r')
197
 
        records = [('rev-id-1', 0, len(gz_txt))]
198
 
        self.assertRaises(errors.KnitCorrupt, data.read_records, records)
199
 
 
200
 
        # read_records_iter_raw won't detect that sort of mismatch/corruption
201
 
        raw_contents = list(data.read_records_iter_raw(records))
202
 
        self.assertEqual([('rev-id-1', gz_txt)], raw_contents)
203
 
 
204
 
    def test_mismatched_version_id(self):
205
 
        sha1sum = sha.new('foo\nbar\n').hexdigest()
206
 
        gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'
207
 
                                        'foo\n'
208
 
                                        'bar\n'
209
 
                                        'end rev-id-1\n'
210
 
                                        % (sha1sum,))
211
 
        transport = MockTransport([gz_txt])
212
 
        data = _KnitData(transport, 'filename', mode='r')
213
 
        # We are asking for rev-id-2, but the data is rev-id-1
214
 
        records = [('rev-id-2', 0, len(gz_txt))]
215
 
        self.assertRaises(errors.KnitCorrupt, data.read_records, records)
216
 
 
217
 
        # read_records_iter_raw will notice if we request the wrong version.
218
 
        self.assertRaises(errors.KnitCorrupt, list,
219
 
                          data.read_records_iter_raw(records))
220
 
 
221
 
    def test_uncompressed_data(self):
222
 
        sha1sum = sha.new('foo\nbar\n').hexdigest()
223
 
        txt = ('version rev-id-1 2 %s\n'
224
 
               'foo\n'
225
 
               'bar\n'
226
 
               'end rev-id-1\n'
227
 
               % (sha1sum,))
228
 
        transport = MockTransport([txt])
229
 
        data = _KnitData(transport, 'filename', mode='r')
230
 
        records = [('rev-id-1', 0, len(txt))]
231
 
 
232
 
        # We don't have valid gzip data ==> corrupt
233
 
        self.assertRaises(errors.KnitCorrupt, data.read_records, records)
234
 
 
235
 
        # read_records_iter_raw will notice the bad data
236
 
        self.assertRaises(errors.KnitCorrupt, list,
237
 
                          data.read_records_iter_raw(records))
238
 
 
239
 
    def test_corrupted_data(self):
240
 
        sha1sum = sha.new('foo\nbar\n').hexdigest()
241
 
        gz_txt = self.create_gz_content('version rev-id-1 2 %s\n'
242
 
                                        'foo\n'
243
 
                                        'bar\n'
244
 
                                        'end rev-id-1\n'
245
 
                                        % (sha1sum,))
246
 
        # Change 2 bytes in the middle to \xff
247
 
        gz_txt = gz_txt[:10] + '\xff\xff' + gz_txt[12:]
248
 
        transport = MockTransport([gz_txt])
249
 
        data = _KnitData(transport, 'filename', mode='r')
250
 
        records = [('rev-id-1', 0, len(gz_txt))]
251
 
 
252
 
        self.assertRaises(errors.KnitCorrupt, data.read_records, records)
253
 
 
254
 
        # read_records_iter_raw will notice if we request the wrong version.
255
 
        self.assertRaises(errors.KnitCorrupt, list,
256
 
                          data.read_records_iter_raw(records))
257
 
 
258
 
 
259
 
class LowLevelKnitIndexTests(TestCase):
260
 
 
261
 
    def get_knit_index(self, *args, **kwargs):
262
 
        orig = knit._load_data
263
 
        def reset():
264
 
            knit._load_data = orig
265
 
        self.addCleanup(reset)
266
 
        from bzrlib._knit_load_data_py import _load_data_py
267
 
        knit._load_data = _load_data_py
268
 
        return _KnitIndex(*args, **kwargs)
269
 
 
270
 
    def test_no_such_file(self):
271
 
        transport = MockTransport()
272
 
 
273
 
        self.assertRaises(NoSuchFile, self.get_knit_index,
274
 
                          transport, "filename", "r")
275
 
        self.assertRaises(NoSuchFile, self.get_knit_index,
276
 
                          transport, "filename", "w", create=False)
277
 
 
278
 
    def test_create_file(self):
279
 
        transport = MockTransport()
280
 
 
281
 
        index = self.get_knit_index(transport, "filename", "w",
282
 
            file_mode="wb", create=True)
283
 
        self.assertEqual(
284
 
                ("put_bytes_non_atomic",
285
 
                    ("filename", index.HEADER), {"mode": "wb"}),
286
 
                transport.calls.pop(0))
287
 
 
288
 
    def test_delay_create_file(self):
289
 
        transport = MockTransport()
290
 
 
291
 
        index = self.get_knit_index(transport, "filename", "w",
292
 
            create=True, file_mode="wb", create_parent_dir=True,
293
 
            delay_create=True, dir_mode=0777)
294
 
        self.assertEqual([], transport.calls)
295
 
 
296
 
        index.add_versions([])
297
 
        name, (filename, f), kwargs = transport.calls.pop(0)
298
 
        self.assertEqual("put_file_non_atomic", name)
299
 
        self.assertEqual(
300
 
            {"dir_mode": 0777, "create_parent_dir": True, "mode": "wb"},
301
 
            kwargs)
302
 
        self.assertEqual("filename", filename)
303
 
        self.assertEqual(index.HEADER, f.read())
304
 
 
305
 
        index.add_versions([])
306
 
        self.assertEqual(("append_bytes", ("filename", ""), {}),
307
 
            transport.calls.pop(0))
308
 
 
309
 
    def test_read_utf8_version_id(self):
310
 
        unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
311
 
        utf8_revision_id = unicode_revision_id.encode('utf-8')
312
 
        transport = MockTransport([
313
 
            _KnitIndex.HEADER,
314
 
            '%s option 0 1 :' % (utf8_revision_id,)
315
 
            ])
316
 
        index = self.get_knit_index(transport, "filename", "r")
317
 
        # _KnitIndex is a private class, and deals in utf8 revision_ids, not
318
 
        # Unicode revision_ids.
319
 
        self.assertTrue(index.has_version(utf8_revision_id))
320
 
        self.assertFalse(index.has_version(unicode_revision_id))
321
 
 
322
 
    def test_read_utf8_parents(self):
323
 
        unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
324
 
        utf8_revision_id = unicode_revision_id.encode('utf-8')
325
 
        transport = MockTransport([
326
 
            _KnitIndex.HEADER,
327
 
            "version option 0 1 .%s :" % (utf8_revision_id,)
328
 
            ])
329
 
        index = self.get_knit_index(transport, "filename", "r")
330
 
        self.assertEqual([utf8_revision_id],
331
 
            index.get_parents_with_ghosts("version"))
332
 
 
333
 
    def test_read_ignore_corrupted_lines(self):
334
 
        transport = MockTransport([
335
 
            _KnitIndex.HEADER,
336
 
            "corrupted",
337
 
            "corrupted options 0 1 .b .c ",
338
 
            "version options 0 1 :"
339
 
            ])
340
 
        index = self.get_knit_index(transport, "filename", "r")
341
 
        self.assertEqual(1, index.num_versions())
342
 
        self.assertTrue(index.has_version("version"))
343
 
 
344
 
    def test_read_corrupted_header(self):
345
 
        transport = MockTransport(['not a bzr knit index header\n'])
346
 
        self.assertRaises(KnitHeaderError,
347
 
            self.get_knit_index, transport, "filename", "r")
348
 
 
349
 
    def test_read_duplicate_entries(self):
350
 
        transport = MockTransport([
351
 
            _KnitIndex.HEADER,
352
 
            "parent options 0 1 :",
353
 
            "version options1 0 1 0 :",
354
 
            "version options2 1 2 .other :",
355
 
            "version options3 3 4 0 .other :"
356
 
            ])
357
 
        index = self.get_knit_index(transport, "filename", "r")
358
 
        self.assertEqual(2, index.num_versions())
359
 
        self.assertEqual(1, index.lookup("version"))
360
 
        self.assertEqual((3, 4), index.get_position("version"))
361
 
        self.assertEqual(["options3"], index.get_options("version"))
362
 
        self.assertEqual(["parent", "other"],
363
 
            index.get_parents_with_ghosts("version"))
364
 
 
365
 
    def test_read_compressed_parents(self):
366
 
        transport = MockTransport([
367
 
            _KnitIndex.HEADER,
368
 
            "a option 0 1 :",
369
 
            "b option 0 1 0 :",
370
 
            "c option 0 1 1 0 :",
371
 
            ])
372
 
        index = self.get_knit_index(transport, "filename", "r")
373
 
        self.assertEqual(["a"], index.get_parents("b"))
374
 
        self.assertEqual(["b", "a"], index.get_parents("c"))
375
 
 
376
 
    def test_write_utf8_version_id(self):
377
 
        unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
378
 
        utf8_revision_id = unicode_revision_id.encode('utf-8')
379
 
        transport = MockTransport([
380
 
            _KnitIndex.HEADER
381
 
            ])
382
 
        index = self.get_knit_index(transport, "filename", "r")
383
 
        index.add_version(utf8_revision_id, ["option"], 0, 1, [])
384
 
        self.assertEqual(("append_bytes", ("filename",
385
 
            "\n%s option 0 1  :" % (utf8_revision_id,)),
386
 
            {}),
387
 
            transport.calls.pop(0))
388
 
 
389
 
    def test_write_utf8_parents(self):
390
 
        unicode_revision_id = u"version-\N{CYRILLIC CAPITAL LETTER A}"
391
 
        utf8_revision_id = unicode_revision_id.encode('utf-8')
392
 
        transport = MockTransport([
393
 
            _KnitIndex.HEADER
394
 
            ])
395
 
        index = self.get_knit_index(transport, "filename", "r")
396
 
        index.add_version("version", ["option"], 0, 1, [utf8_revision_id])
397
 
        self.assertEqual(("append_bytes", ("filename",
398
 
            "\nversion option 0 1 .%s :" % (utf8_revision_id,)),
399
 
            {}),
400
 
            transport.calls.pop(0))
401
 
 
402
 
    def test_get_graph(self):
403
 
        transport = MockTransport()
404
 
        index = self.get_knit_index(transport, "filename", "w", create=True)
405
 
        self.assertEqual([], index.get_graph())
406
 
 
407
 
        index.add_version("a", ["option"], 0, 1, ["b"])
408
 
        self.assertEqual([("a", ["b"])], index.get_graph())
409
 
 
410
 
        index.add_version("c", ["option"], 0, 1, ["d"])
411
 
        self.assertEqual([("a", ["b"]), ("c", ["d"])],
412
 
            sorted(index.get_graph()))
413
 
 
414
 
    def test_get_ancestry(self):
415
 
        transport = MockTransport([
416
 
            _KnitIndex.HEADER,
417
 
            "a option 0 1 :",
418
 
            "b option 0 1 0 .e :",
419
 
            "c option 0 1 1 0 :",
420
 
            "d option 0 1 2 .f :"
421
 
            ])
422
 
        index = self.get_knit_index(transport, "filename", "r")
423
 
 
424
 
        self.assertEqual([], index.get_ancestry([]))
425
 
        self.assertEqual(["a"], index.get_ancestry(["a"]))
426
 
        self.assertEqual(["a", "b"], index.get_ancestry(["b"]))
427
 
        self.assertEqual(["a", "b", "c"], index.get_ancestry(["c"]))
428
 
        self.assertEqual(["a", "b", "c", "d"], index.get_ancestry(["d"]))
429
 
        self.assertEqual(["a", "b"], index.get_ancestry(["a", "b"]))
430
 
        self.assertEqual(["a", "b", "c"], index.get_ancestry(["a", "c"]))
431
 
 
432
 
        self.assertRaises(RevisionNotPresent, index.get_ancestry, ["e"])
433
 
 
434
 
    def test_get_ancestry_with_ghosts(self):
435
 
        transport = MockTransport([
436
 
            _KnitIndex.HEADER,
437
 
            "a option 0 1 :",
438
 
            "b option 0 1 0 .e :",
439
 
            "c option 0 1 0 .f .g :",
440
 
            "d option 0 1 2 .h .j .k :"
441
 
            ])
442
 
        index = self.get_knit_index(transport, "filename", "r")
443
 
 
444
 
        self.assertEqual([], index.get_ancestry_with_ghosts([]))
445
 
        self.assertEqual(["a"], index.get_ancestry_with_ghosts(["a"]))
446
 
        self.assertEqual(["a", "e", "b"],
447
 
            index.get_ancestry_with_ghosts(["b"]))
448
 
        self.assertEqual(["a", "g", "f", "c"],
449
 
            index.get_ancestry_with_ghosts(["c"]))
450
 
        self.assertEqual(["a", "g", "f", "c", "k", "j", "h", "d"],
451
 
            index.get_ancestry_with_ghosts(["d"]))
452
 
        self.assertEqual(["a", "e", "b"],
453
 
            index.get_ancestry_with_ghosts(["a", "b"]))
454
 
        self.assertEqual(["a", "g", "f", "c"],
455
 
            index.get_ancestry_with_ghosts(["a", "c"]))
456
 
        self.assertEqual(
457
 
            ["a", "g", "f", "c", "e", "b", "k", "j", "h", "d"],
458
 
            index.get_ancestry_with_ghosts(["b", "d"]))
459
 
 
460
 
        self.assertRaises(RevisionNotPresent,
461
 
            index.get_ancestry_with_ghosts, ["e"])
462
 
 
463
 
    def test_num_versions(self):
464
 
        transport = MockTransport([
465
 
            _KnitIndex.HEADER
466
 
            ])
467
 
        index = self.get_knit_index(transport, "filename", "r")
468
 
 
469
 
        self.assertEqual(0, index.num_versions())
470
 
        self.assertEqual(0, len(index))
471
 
 
472
 
        index.add_version("a", ["option"], 0, 1, [])
473
 
        self.assertEqual(1, index.num_versions())
474
 
        self.assertEqual(1, len(index))
475
 
 
476
 
        index.add_version("a", ["option2"], 1, 2, [])
477
 
        self.assertEqual(1, index.num_versions())
478
 
        self.assertEqual(1, len(index))
479
 
 
480
 
        index.add_version("b", ["option"], 0, 1, [])
481
 
        self.assertEqual(2, index.num_versions())
482
 
        self.assertEqual(2, len(index))
483
 
 
484
 
    def test_get_versions(self):
485
 
        transport = MockTransport([
486
 
            _KnitIndex.HEADER
487
 
            ])
488
 
        index = self.get_knit_index(transport, "filename", "r")
489
 
 
490
 
        self.assertEqual([], index.get_versions())
491
 
 
492
 
        index.add_version("a", ["option"], 0, 1, [])
493
 
        self.assertEqual(["a"], index.get_versions())
494
 
 
495
 
        index.add_version("a", ["option"], 0, 1, [])
496
 
        self.assertEqual(["a"], index.get_versions())
497
 
 
498
 
        index.add_version("b", ["option"], 0, 1, [])
499
 
        self.assertEqual(["a", "b"], index.get_versions())
500
 
 
501
 
    def test_idx_to_name(self):
502
 
        transport = MockTransport([
503
 
            _KnitIndex.HEADER,
504
 
            "a option 0 1 :",
505
 
            "b option 0 1 :"
506
 
            ])
507
 
        index = self.get_knit_index(transport, "filename", "r")
508
 
 
509
 
        self.assertEqual("a", index.idx_to_name(0))
510
 
        self.assertEqual("b", index.idx_to_name(1))
511
 
        self.assertEqual("b", index.idx_to_name(-1))
512
 
        self.assertEqual("a", index.idx_to_name(-2))
513
 
 
514
 
    def test_lookup(self):
515
 
        transport = MockTransport([
516
 
            _KnitIndex.HEADER,
517
 
            "a option 0 1 :",
518
 
            "b option 0 1 :"
519
 
            ])
520
 
        index = self.get_knit_index(transport, "filename", "r")
521
 
 
522
 
        self.assertEqual(0, index.lookup("a"))
523
 
        self.assertEqual(1, index.lookup("b"))
524
 
 
525
 
    def test_add_version(self):
526
 
        transport = MockTransport([
527
 
            _KnitIndex.HEADER
528
 
            ])
529
 
        index = self.get_knit_index(transport, "filename", "r")
530
 
 
531
 
        index.add_version("a", ["option"], 0, 1, ["b"])
532
 
        self.assertEqual(("append_bytes",
533
 
            ("filename", "\na option 0 1 .b :"),
534
 
            {}), transport.calls.pop(0))
535
 
        self.assertTrue(index.has_version("a"))
536
 
        self.assertEqual(1, index.num_versions())
537
 
        self.assertEqual((0, 1), index.get_position("a"))
538
 
        self.assertEqual(["option"], index.get_options("a"))
539
 
        self.assertEqual(["b"], index.get_parents_with_ghosts("a"))
540
 
 
541
 
        index.add_version("a", ["opt"], 1, 2, ["c"])
542
 
        self.assertEqual(("append_bytes",
543
 
            ("filename", "\na opt 1 2 .c :"),
544
 
            {}), transport.calls.pop(0))
545
 
        self.assertTrue(index.has_version("a"))
546
 
        self.assertEqual(1, index.num_versions())
547
 
        self.assertEqual((1, 2), index.get_position("a"))
548
 
        self.assertEqual(["opt"], index.get_options("a"))
549
 
        self.assertEqual(["c"], index.get_parents_with_ghosts("a"))
550
 
 
551
 
        index.add_version("b", ["option"], 2, 3, ["a"])
552
 
        self.assertEqual(("append_bytes",
553
 
            ("filename", "\nb option 2 3 0 :"),
554
 
            {}), transport.calls.pop(0))
555
 
        self.assertTrue(index.has_version("b"))
556
 
        self.assertEqual(2, index.num_versions())
557
 
        self.assertEqual((2, 3), index.get_position("b"))
558
 
        self.assertEqual(["option"], index.get_options("b"))
559
 
        self.assertEqual(["a"], index.get_parents_with_ghosts("b"))
560
 
 
561
 
    def test_add_versions(self):
562
 
        transport = MockTransport([
563
 
            _KnitIndex.HEADER
564
 
            ])
565
 
        index = self.get_knit_index(transport, "filename", "r")
566
 
 
567
 
        index.add_versions([
568
 
            ("a", ["option"], 0, 1, ["b"]),
569
 
            ("a", ["opt"], 1, 2, ["c"]),
570
 
            ("b", ["option"], 2, 3, ["a"])
571
 
            ])
572
 
        self.assertEqual(("append_bytes", ("filename",
573
 
            "\na option 0 1 .b :"
574
 
            "\na opt 1 2 .c :"
575
 
            "\nb option 2 3 0 :"
576
 
            ), {}), transport.calls.pop(0))
577
 
        self.assertTrue(index.has_version("a"))
578
 
        self.assertTrue(index.has_version("b"))
579
 
        self.assertEqual(2, index.num_versions())
580
 
        self.assertEqual((1, 2), index.get_position("a"))
581
 
        self.assertEqual((2, 3), index.get_position("b"))
582
 
        self.assertEqual(["opt"], index.get_options("a"))
583
 
        self.assertEqual(["option"], index.get_options("b"))
584
 
        self.assertEqual(["c"], index.get_parents_with_ghosts("a"))
585
 
        self.assertEqual(["a"], index.get_parents_with_ghosts("b"))
586
 
 
587
 
    def test_delay_create_and_add_versions(self):
588
 
        transport = MockTransport()
589
 
 
590
 
        index = self.get_knit_index(transport, "filename", "w",
591
 
            create=True, file_mode="wb", create_parent_dir=True,
592
 
            delay_create=True, dir_mode=0777)
593
 
        self.assertEqual([], transport.calls)
594
 
 
595
 
        index.add_versions([
596
 
            ("a", ["option"], 0, 1, ["b"]),
597
 
            ("a", ["opt"], 1, 2, ["c"]),
598
 
            ("b", ["option"], 2, 3, ["a"])
599
 
            ])
600
 
        name, (filename, f), kwargs = transport.calls.pop(0)
601
 
        self.assertEqual("put_file_non_atomic", name)
602
 
        self.assertEqual(
603
 
            {"dir_mode": 0777, "create_parent_dir": True, "mode": "wb"},
604
 
            kwargs)
605
 
        self.assertEqual("filename", filename)
606
 
        self.assertEqual(
607
 
            index.HEADER +
608
 
            "\na option 0 1 .b :"
609
 
            "\na opt 1 2 .c :"
610
 
            "\nb option 2 3 0 :",
611
 
            f.read())
612
 
 
613
 
    def test_has_version(self):
614
 
        transport = MockTransport([
615
 
            _KnitIndex.HEADER,
616
 
            "a option 0 1 :"
617
 
            ])
618
 
        index = self.get_knit_index(transport, "filename", "r")
619
 
 
620
 
        self.assertTrue(index.has_version("a"))
621
 
        self.assertFalse(index.has_version("b"))
622
 
 
623
 
    def test_get_position(self):
624
 
        transport = MockTransport([
625
 
            _KnitIndex.HEADER,
626
 
            "a option 0 1 :",
627
 
            "b option 1 2 :"
628
 
            ])
629
 
        index = self.get_knit_index(transport, "filename", "r")
630
 
 
631
 
        self.assertEqual((0, 1), index.get_position("a"))
632
 
        self.assertEqual((1, 2), index.get_position("b"))
633
 
 
634
 
    def test_get_method(self):
635
 
        transport = MockTransport([
636
 
            _KnitIndex.HEADER,
637
 
            "a fulltext,unknown 0 1 :",
638
 
            "b unknown,line-delta 1 2 :",
639
 
            "c bad 3 4 :"
640
 
            ])
641
 
        index = self.get_knit_index(transport, "filename", "r")
642
 
 
643
 
        self.assertEqual("fulltext", index.get_method("a"))
644
 
        self.assertEqual("line-delta", index.get_method("b"))
645
 
        self.assertRaises(errors.KnitIndexUnknownMethod, index.get_method, "c")
646
 
 
647
 
    def test_get_options(self):
648
 
        transport = MockTransport([
649
 
            _KnitIndex.HEADER,
650
 
            "a opt1 0 1 :",
651
 
            "b opt2,opt3 1 2 :"
652
 
            ])
653
 
        index = self.get_knit_index(transport, "filename", "r")
654
 
 
655
 
        self.assertEqual(["opt1"], index.get_options("a"))
656
 
        self.assertEqual(["opt2", "opt3"], index.get_options("b"))
657
 
 
658
 
    def test_get_parents(self):
659
 
        transport = MockTransport([
660
 
            _KnitIndex.HEADER,
661
 
            "a option 0 1 :",
662
 
            "b option 1 2 0 .c :",
663
 
            "c option 1 2 1 0 .e :"
664
 
            ])
665
 
        index = self.get_knit_index(transport, "filename", "r")
666
 
 
667
 
        self.assertEqual([], index.get_parents("a"))
668
 
        self.assertEqual(["a", "c"], index.get_parents("b"))
669
 
        self.assertEqual(["b", "a"], index.get_parents("c"))
670
 
 
671
 
    def test_get_parents_with_ghosts(self):
672
 
        transport = MockTransport([
673
 
            _KnitIndex.HEADER,
674
 
            "a option 0 1 :",
675
 
            "b option 1 2 0 .c :",
676
 
            "c option 1 2 1 0 .e :"
677
 
            ])
678
 
        index = self.get_knit_index(transport, "filename", "r")
679
 
 
680
 
        self.assertEqual([], index.get_parents_with_ghosts("a"))
681
 
        self.assertEqual(["a", "c"], index.get_parents_with_ghosts("b"))
682
 
        self.assertEqual(["b", "a", "e"],
683
 
            index.get_parents_with_ghosts("c"))
684
 
 
685
 
    def test_check_versions_present(self):
686
 
        transport = MockTransport([
687
 
            _KnitIndex.HEADER,
688
 
            "a option 0 1 :",
689
 
            "b option 0 1 :"
690
 
            ])
691
 
        index = self.get_knit_index(transport, "filename", "r")
692
 
 
693
 
        check = index.check_versions_present
694
 
 
695
 
        check([])
696
 
        check(["a"])
697
 
        check(["b"])
698
 
        check(["a", "b"])
699
 
        self.assertRaises(RevisionNotPresent, check, ["c"])
700
 
        self.assertRaises(RevisionNotPresent, check, ["a", "b", "c"])
701
 
 
702
 
    def test_impossible_parent(self):
703
 
        """Test we get KnitCorrupt if the parent couldn't possibly exist."""
704
 
        transport = MockTransport([
705
 
            _KnitIndex.HEADER,
706
 
            "a option 0 1 :",
707
 
            "b option 0 1 4 :"  # We don't have a 4th record
708
 
            ])
709
 
        try:
710
 
            self.assertRaises(errors.KnitCorrupt,
711
 
                              self.get_knit_index, transport, 'filename', 'r')
712
 
        except TypeError, e:
713
 
            if (str(e) == ('exceptions must be strings, classes, or instances,'
714
 
                           ' not exceptions.IndexError')
715
 
                and sys.version_info[0:2] >= (2,5)):
716
 
                self.knownFailure('Pyrex <0.9.5 fails with TypeError when'
717
 
                                  ' raising new style exceptions with python'
718
 
                                  ' >=2.5')
719
 
            else:
720
 
                raise
721
 
 
722
 
    def test_corrupted_parent(self):
723
 
        transport = MockTransport([
724
 
            _KnitIndex.HEADER,
725
 
            "a option 0 1 :",
726
 
            "b option 0 1 :",
727
 
            "c option 0 1 1v :", # Can't have a parent of '1v'
728
 
            ])
729
 
        try:
730
 
            self.assertRaises(errors.KnitCorrupt,
731
 
                              self.get_knit_index, transport, 'filename', 'r')
732
 
        except TypeError, e:
733
 
            if (str(e) == ('exceptions must be strings, classes, or instances,'
734
 
                           ' not exceptions.ValueError')
735
 
                and sys.version_info[0:2] >= (2,5)):
736
 
                self.knownFailure('Pyrex <0.9.5 fails with TypeError when'
737
 
                                  ' raising new style exceptions with python'
738
 
                                  ' >=2.5')
739
 
            else:
740
 
                raise
741
 
 
742
 
    def test_corrupted_parent_in_list(self):
743
 
        transport = MockTransport([
744
 
            _KnitIndex.HEADER,
745
 
            "a option 0 1 :",
746
 
            "b option 0 1 :",
747
 
            "c option 0 1 1 v :", # Can't have a parent of 'v'
748
 
            ])
749
 
        try:
750
 
            self.assertRaises(errors.KnitCorrupt,
751
 
                              self.get_knit_index, transport, 'filename', 'r')
752
 
        except TypeError, e:
753
 
            if (str(e) == ('exceptions must be strings, classes, or instances,'
754
 
                           ' not exceptions.ValueError')
755
 
                and sys.version_info[0:2] >= (2,5)):
756
 
                self.knownFailure('Pyrex <0.9.5 fails with TypeError when'
757
 
                                  ' raising new style exceptions with python'
758
 
                                  ' >=2.5')
759
 
            else:
760
 
                raise
761
 
 
762
 
    def test_invalid_position(self):
763
 
        transport = MockTransport([
764
 
            _KnitIndex.HEADER,
765
 
            "a option 1v 1 :",
766
 
            ])
767
 
        try:
768
 
            self.assertRaises(errors.KnitCorrupt,
769
 
                              self.get_knit_index, transport, 'filename', 'r')
770
 
        except TypeError, e:
771
 
            if (str(e) == ('exceptions must be strings, classes, or instances,'
772
 
                           ' not exceptions.ValueError')
773
 
                and sys.version_info[0:2] >= (2,5)):
774
 
                self.knownFailure('Pyrex <0.9.5 fails with TypeError when'
775
 
                                  ' raising new style exceptions with python'
776
 
                                  ' >=2.5')
777
 
            else:
778
 
                raise
779
 
 
780
 
    def test_invalid_size(self):
781
 
        transport = MockTransport([
782
 
            _KnitIndex.HEADER,
783
 
            "a option 1 1v :",
784
 
            ])
785
 
        try:
786
 
            self.assertRaises(errors.KnitCorrupt,
787
 
                              self.get_knit_index, transport, 'filename', 'r')
788
 
        except TypeError, e:
789
 
            if (str(e) == ('exceptions must be strings, classes, or instances,'
790
 
                           ' not exceptions.ValueError')
791
 
                and sys.version_info[0:2] >= (2,5)):
792
 
                self.knownFailure('Pyrex <0.9.5 fails with TypeError when'
793
 
                                  ' raising new style exceptions with python'
794
 
                                  ' >=2.5')
795
 
            else:
796
 
                raise
797
 
 
798
 
    def test_short_line(self):
799
 
        transport = MockTransport([
800
 
            _KnitIndex.HEADER,
801
 
            "a option 0 10  :",
802
 
            "b option 10 10 0", # This line isn't terminated, ignored
803
 
            ])
804
 
        index = self.get_knit_index(transport, "filename", "r")
805
 
        self.assertEqual(['a'], index.get_versions())
806
 
 
807
 
    def test_skip_incomplete_record(self):
808
 
        # A line with bogus data should just be skipped
809
 
        transport = MockTransport([
810
 
            _KnitIndex.HEADER,
811
 
            "a option 0 10  :",
812
 
            "b option 10 10 0", # This line isn't terminated, ignored
813
 
            "c option 20 10 0 :", # Properly terminated, and starts with '\n'
814
 
            ])
815
 
        index = self.get_knit_index(transport, "filename", "r")
816
 
        self.assertEqual(['a', 'c'], index.get_versions())
817
 
 
818
 
    def test_trailing_characters(self):
819
 
        # A line with bogus data should just be skipped
820
 
        transport = MockTransport([
821
 
            _KnitIndex.HEADER,
822
 
            "a option 0 10  :",
823
 
            "b option 10 10 0 :a", # This line has extra trailing characters
824
 
            "c option 20 10 0 :", # Properly terminated, and starts with '\n'
825
 
            ])
826
 
        index = self.get_knit_index(transport, "filename", "r")
827
 
        self.assertEqual(['a', 'c'], index.get_versions())
828
 
 
829
 
 
830
 
class LowLevelKnitIndexTests_c(LowLevelKnitIndexTests):
831
 
 
832
 
    _test_needs_features = [CompiledKnitFeature]
833
 
 
834
 
    def get_knit_index(self, *args, **kwargs):
835
 
        orig = knit._load_data
836
 
        def reset():
837
 
            knit._load_data = orig
838
 
        self.addCleanup(reset)
839
 
        from bzrlib._knit_load_data_c import _load_data_c
840
 
        knit._load_data = _load_data_c
841
 
        return _KnitIndex(*args, **kwargs)
842
 
 
843
 
 
844
 
 
845
36
class KnitTests(TestCaseWithTransport):
846
37
    """Class containing knit test helper routines."""
847
38
 
1141
332
        knit = KnitVersionedFile('test', get_transport('.'), access_mode='r')
1142
333
        self.assertEqual(['revid', 'revid2'], knit.versions())
1143
334
        # write a short write to the file and ensure that its ignored
1144
 
        indexfile = file('test.kndx', 'ab')
 
335
        indexfile = file('test.kndx', 'at')
1145
336
        indexfile.write('\nrevid3 line-delta 166 82 1 2 3 4 5 .phwoar:demo ')
1146
337
        indexfile.close()
1147
338
        # we should be able to load this file again
1439
630
        text = k.get_text('text-1')
1440
631
        self.assertEqual(TEXT_1, text)
1441
632
        self.assertEqual({}, k._data._cache)
1442
 
 
1443
 
 
1444
 
class TestKnitIndex(KnitTests):
1445
 
 
1446
 
    def test_add_versions_dictionary_compresses(self):
1447
 
        """Adding versions to the index should update the lookup dict"""
1448
 
        knit = self.make_test_knit()
1449
 
        idx = knit._index
1450
 
        idx.add_version('a-1', ['fulltext'], 0, 0, [])
1451
 
        self.check_file_contents('test.kndx',
1452
 
            '# bzr knit index 8\n'
1453
 
            '\n'
1454
 
            'a-1 fulltext 0 0  :'
1455
 
            )
1456
 
        idx.add_versions([('a-2', ['fulltext'], 0, 0, ['a-1']),
1457
 
                          ('a-3', ['fulltext'], 0, 0, ['a-2']),
1458
 
                         ])
1459
 
        self.check_file_contents('test.kndx',
1460
 
            '# bzr knit index 8\n'
1461
 
            '\n'
1462
 
            'a-1 fulltext 0 0  :\n'
1463
 
            'a-2 fulltext 0 0 0 :\n'
1464
 
            'a-3 fulltext 0 0 1 :'
1465
 
            )
1466
 
        self.assertEqual(['a-1', 'a-2', 'a-3'], idx._history)
1467
 
        self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, [], 0),
1468
 
                          'a-2':('a-2', ['fulltext'], 0, 0, ['a-1'], 1),
1469
 
                          'a-3':('a-3', ['fulltext'], 0, 0, ['a-2'], 2),
1470
 
                         }, idx._cache)
1471
 
 
1472
 
    def test_add_versions_fails_clean(self):
1473
 
        """If add_versions fails in the middle, it restores a pristine state.
1474
 
 
1475
 
        Any modifications that are made to the index are reset if all versions
1476
 
        cannot be added.
1477
 
        """
1478
 
        # This cheats a little bit by passing in a generator which will
1479
 
        # raise an exception before the processing finishes
1480
 
        # Other possibilities would be to have an version with the wrong number
1481
 
        # of entries, or to make the backing transport unable to write any
1482
 
        # files.
1483
 
 
1484
 
        knit = self.make_test_knit()
1485
 
        idx = knit._index
1486
 
        idx.add_version('a-1', ['fulltext'], 0, 0, [])
1487
 
 
1488
 
        class StopEarly(Exception):
1489
 
            pass
1490
 
 
1491
 
        def generate_failure():
1492
 
            """Add some entries and then raise an exception"""
1493
 
            yield ('a-2', ['fulltext'], 0, 0, ['a-1'])
1494
 
            yield ('a-3', ['fulltext'], 0, 0, ['a-2'])
1495
 
            raise StopEarly()
1496
 
 
1497
 
        # Assert the pre-condition
1498
 
        self.assertEqual(['a-1'], idx._history)
1499
 
        self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, [], 0)}, idx._cache)
1500
 
 
1501
 
        self.assertRaises(StopEarly, idx.add_versions, generate_failure())
1502
 
 
1503
 
        # And it shouldn't be modified
1504
 
        self.assertEqual(['a-1'], idx._history)
1505
 
        self.assertEqual({'a-1':('a-1', ['fulltext'], 0, 0, [], 0)}, idx._cache)
1506
 
 
1507
 
    def test_knit_index_ignores_empty_files(self):
1508
 
        # There was a race condition in older bzr, where a ^C at the right time
1509
 
        # could leave an empty .kndx file, which bzr would later claim was a
1510
 
        # corrupted file since the header was not present. In reality, the file
1511
 
        # just wasn't created, so it should be ignored.
1512
 
        t = get_transport('.')
1513
 
        t.put_bytes('test.kndx', '')
1514
 
 
1515
 
        knit = self.make_test_knit()
1516
 
 
1517
 
    def test_knit_index_checks_header(self):
1518
 
        t = get_transport('.')
1519
 
        t.put_bytes('test.kndx', '# not really a knit header\n\n')
1520
 
 
1521
 
        self.assertRaises(KnitHeaderError, self.make_test_knit)