To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to breezy/tests/test_weave.py
- browse files at revision 6963.2.17
- compare with another revision
- compare with revision 5200.3.2
- download diff
- download tarball
- view history from revision 6963.2.17
- Committer: Jelmer Vernooij
- Date: 2018-05-22 01:30:48 UTC
- mto: (6973.5.4 python3-c)
- mto: This revision was merged to the branch mainline in revision 6984.
- Revision ID: jelmer@jelmer.uk-20180522013048-r825wjanpr2yqige
port breezy.bzr.weave to Python3.
- files modified:
- breezy/bzr/weavefile.py
added
removed
breezy/tests/test_weave.py
36
36
37
37
38
38
# texts for use in testing
39
TEXT_0 = ["Hello world"]
40
TEXT_1 = ["Hello world",
41
"A second line"]
39
TEXT_0 = [b"Hello world"]
40
TEXT_1 = [b"Hello world",
41
b"A second line"]
42
42
43
43
44
44
class TestBase(TestCase):
70
70
71
71
def runTest(self):
72
72
k = Weave(get_scope=lambda:None)
73
self.assertFalse('foo' in k)
74
k.add_lines('foo', [], TEXT_1)
75
self.assertTrue('foo' in k)
73
self.assertFalse(b'foo' in k)
74
k.add_lines(b'foo', [], TEXT_1)
75
self.assertTrue(b'foo' in k)
76
76
77
77
78
78
class Easy(TestBase):
85
85
86
86
def runTest(self):
87
87
k = Weave()
88
k.add_lines('text0', [], TEXT_0)
89
self.assertEqual(k.annotate('text0'),
90
[('text0', TEXT_0[0])])
88
k.add_lines(b'text0', [], TEXT_0)
89
self.assertEqual(k.annotate(b'text0'),
90
[(b'text0', TEXT_0[0])])
91
91
92
92
93
93
class InvalidAdd(TestBase):
98
98
99
99
self.assertRaises(errors.RevisionNotPresent,
100
100
k.add_lines,
101
'text0',
102
['69'],
103
['new text!'])
101
b'text0',
102
[b'69'],
103
[b'new text!'])
104
104
105
105
106
106
class RepeatedAdd(TestBase):
108
108
109
109
def test_duplicate_add(self):
110
110
k = Weave()
111
idx = k.add_lines('text0', [], TEXT_0)
112
idx2 = k.add_lines('text0', [], TEXT_0)
111
idx = k.add_lines(b'text0', [], TEXT_0)
112
idx2 = k.add_lines(b'text0', [], TEXT_0)
113
113
self.assertEqual(idx, idx2)
114
114
115
115
117
117
118
118
def runTest(self):
119
119
k = Weave()
120
k.add_lines('basis', [], TEXT_0)
121
idx = k.add_lines('text0', [], TEXT_0)
120
k.add_lines(b'basis', [], TEXT_0)
121
idx = k.add_lines(b'text0', [], TEXT_0)
122
122
self.assertRaises(errors.RevisionAlreadyPresent,
123
123
k.add_lines,
124
'text0',
124
b'text0',
125
125
[],
126
['not the same text'])
126
[b'not the same text'])
127
127
self.assertRaises(errors.RevisionAlreadyPresent,
128
128
k.add_lines,
129
'text0',
130
['basis'], # not the right parents
129
b'text0',
130
[b'basis'], # not the right parents
131
131
TEXT_0)
132
132
133
133
139
139
def runTest(self):
140
140
k = Weave()
141
141
142
k.add_lines('text0', [], ['line 1'])
143
k.add_lines('text1', ['text0'], ['line 1', 'line 2'])
142
k.add_lines(b'text0', [], [b'line 1'])
143
k.add_lines(b'text1', [b'text0'], [b'line 1', b'line 2'])
144
144
145
self.assertEqual(k.annotate('text0'),
146
[('text0', 'line 1')])
145
self.assertEqual(k.annotate(b'text0'),
146
[(b'text0', b'line 1')])
147
147
148
148
self.assertEqual(k.get_lines(1),
149
['line 1',
150
'line 2'])
151
152
self.assertEqual(k.annotate('text1'),
153
[('text0', 'line 1'),
154
('text1', 'line 2')])
155
156
k.add_lines('text2', ['text0'], ['line 1', 'diverged line'])
157
158
self.assertEqual(k.annotate('text2'),
159
[('text0', 'line 1'),
160
('text2', 'diverged line')])
161
162
text3 = ['line 1', 'middle line', 'line 2']
163
k.add_lines('text3',
164
['text0', 'text1'],
149
[b'line 1',
150
b'line 2'])
151
152
self.assertEqual(k.annotate(b'text1'),
153
[(b'text0', b'line 1'),
154
(b'text1', b'line 2')])
155
156
k.add_lines(b'text2', [b'text0'], [b'line 1', b'diverged line'])
157
158
self.assertEqual(k.annotate(b'text2'),
159
[(b'text0', b'line 1'),
160
(b'text2', b'diverged line')])
161
162
text3 = [b'line 1', b'middle line', b'line 2']
163
k.add_lines(b'text3',
164
[b'text0', b'text1'],
165
165
text3)
166
166
167
167
# self.log("changes to text3: " + pformat(list(k._delta(set([0, 1]), text3))))
168
168
169
169
self.log("k._weave=" + pformat(k._weave))
170
170
171
self.assertEqual(k.annotate('text3'),
172
[('text0', 'line 1'),
173
('text3', 'middle line'),
174
('text1', 'line 2')])
171
self.assertEqual(k.annotate(b'text3'),
172
[(b'text0', b'line 1'),
173
(b'text3', b'middle line'),
174
(b'text1', b'line 2')])
175
175
176
176
# now multiple insertions at different places
177
k.add_lines('text4',
178
['text0', 'text1', 'text3'],
179
['line 1', 'aaa', 'middle line', 'bbb', 'line 2', 'ccc'])
177
k.add_lines(b'text4',
178
[b'text0', b'text1', b'text3'],
179
[b'line 1', b'aaa', b'middle line', b'bbb', b'line 2', b'ccc'])
180
180
181
self.assertEqual(k.annotate('text4'),
182
[('text0', 'line 1'),
183
('text4', 'aaa'),
184
('text3', 'middle line'),
185
('text4', 'bbb'),
186
('text1', 'line 2'),
187
('text4', 'ccc')])
181
self.assertEqual(k.annotate(b'text4'),
182
[(b'text0', b'line 1'),
183
(b'text4', b'aaa'),
184
(b'text3', b'middle line'),
185
(b'text4', b'bbb'),
186
(b'text1', b'line 2'),
187
(b'text4', b'ccc')])
188
188
189
189
190
190
class DeleteLines(TestBase):
194
194
def runTest(self):
195
195
k = Weave()
196
196
197
base_text = ['one', 'two', 'three', 'four']
198
199
k.add_lines('text0', [], base_text)
200
201
texts = [['one', 'two', 'three'],
202
['two', 'three', 'four'],
203
['one', 'four'],
204
['one', 'two', 'three', 'four'],
197
base_text = [b'one', b'two', b'three', b'four']
198
199
k.add_lines(b'text0', [], base_text)
200
201
texts = [[b'one', b'two', b'three'],
202
[b'two', b'three', b'four'],
203
[b'one', b'four'],
204
[b'one', b'two', b'three', b'four'],
205
205
]
206
206
207
207
i = 1
208
208
for t in texts:
209
ver = k.add_lines('text%d' % i,
210
['text0'], t)
209
ver = k.add_lines(b'text%d' % i,
210
[b'text0'], t)
211
211
i += 1
212
212
213
213
self.log('final weave:')
225
225
226
226
k._parents = [(),
227
227
]
228
k._weave = [('{', 0),
229
'first line',
230
('[', 0),
231
'deleted in 0',
232
(']', 0),
233
('}', 0),
228
k._weave = [(b'{', 0),
229
b'first line',
230
(b'[', 0),
231
b'deleted in 0',
232
(b']', 0),
233
(b'}', 0),
234
234
]
235
235
################################### SKIPPED
236
236
# Weave.get doesn't trap this anymore
249
249
k._parents = [(),
250
250
frozenset([0]),
251
251
]
252
k._weave = [('{', 0),
253
'first line',
254
('[', 1),
255
'line to be deleted',
256
(']', 1),
257
'last line',
258
('}', 0),
252
k._weave = [(b'{', 0),
253
b'first line',
254
(b'[', 1),
255
b'line to be deleted',
256
(b']', 1),
257
b'last line',
258
(b'}', 0),
259
259
]
260
k._sha1s = [sha_string('first lineline to be deletedlast line')
261
, sha_string('first linelast line')]
260
k._sha1s = [sha_string(b'first lineline to be deletedlast line')
261
, sha_string(b'first linelast line')]
262
262
263
263
self.assertEqual(k.get_lines(0),
264
['first line',
265
'line to be deleted',
266
'last line',
264
[b'first line',
265
b'line to be deleted',
266
b'last line',
267
267
])
268
268
269
269
self.assertEqual(k.get_lines(1),
270
['first line',
271
'last line',
270
[b'first line',
271
b'last line',
272
272
])
273
273
274
274
280
280
k._parents = [frozenset(),
281
281
frozenset([0]),
282
282
]
283
k._weave = [('{', 0),
284
'first line',
285
('[', 1),
286
'line to be deleted',
287
(']', 1),
288
('{', 1),
289
'replacement line',
290
('}', 1),
291
'last line',
292
('}', 0),
283
k._weave = [(b'{', 0),
284
b'first line',
285
(b'[', 1),
286
b'line to be deleted',
287
(b']', 1),
288
(b'{', 1),
289
b'replacement line',
290
(b'}', 1),
291
b'last line',
292
(b'}', 0),
293
293
]
294
k._sha1s = [sha_string('first lineline to be deletedlast line')
295
, sha_string('first linereplacement linelast line')]
294
k._sha1s = [sha_string(b'first lineline to be deletedlast line')
295
, sha_string(b'first linereplacement linelast line')]
296
296
297
297
self.assertEqual(k.get_lines(0),
298
['first line',
299
'line to be deleted',
300
'last line',
298
[b'first line',
299
b'line to be deleted',
300
b'last line',
301
301
])
302
302
303
303
self.assertEqual(k.get_lines(1),
304
['first line',
305
'replacement line',
306
'last line',
304
[b'first line',
305
b'replacement line',
306
b'last line',
307
307
])
308
308
309
309
314
314
315
315
k._parents = [frozenset(),
316
316
]
317
k._weave = ['bad line',
318
('{', 0),
319
'foo {',
320
('{', 1),
321
' added in version 1',
322
('{', 2),
323
' added in v2',
324
('}', 2),
325
' also from v1',
326
('}', 1),
327
'}',
328
('}', 0)]
317
k._weave = [b'bad line',
318
(b'{', 0),
319
b'foo {',
320
(b'{', 1),
321
b' added in version 1',
322
(b'{', 2),
323
b' added in v2',
324
(b'}', 2),
325
b' also from v1',
326
(b'}', 1),
327
b'}',
328
(b'}', 0)]
329
329
330
330
################################### SKIPPED
331
331
# Weave.get doesn't trap this anymore
347
347
frozenset([0]),
348
348
frozenset([0, 1, 2]),
349
349
]
350
k._weave = [('{', 0),
351
'foo {',
352
('{', 1),
353
' added in version 1',
354
('{', 1),
355
' more in 1',
356
('}', 1),
357
('}', 1),
358
('}', 0)]
350
k._weave = [(b'{', 0),
351
b'foo {',
352
(b'{', 1),
353
b' added in version 1',
354
(b'{', 1),
355
b' more in 1',
356
(b'}', 1),
357
(b'}', 1),
358
(b'}', 0)]
359
359
360
360
361
361
# this is not currently enforced by get
380
380
frozenset([0]),
381
381
frozenset([0, 1, 2]),
382
382
]
383
k._weave = [('{', 0),
384
'foo {',
385
('{', 1),
386
' added in version 1',
387
('{', 2),
388
' added in v2',
389
('}', 2),
390
' also from v1',
391
('}', 1),
392
'}',
393
('}', 0)]
383
k._weave = [(b'{', 0),
384
b'foo {',
385
(b'{', 1),
386
b' added in version 1',
387
(b'{', 2),
388
b' added in v2',
389
(b'}', 2),
390
b' also from v1',
391
(b'}', 1),
392
b'}',
393
(b'}', 0)]
394
394
395
k._sha1s = [sha_string('foo {}')
396
, sha_string('foo { added in version 1 also from v1}')
397
, sha_string('foo { added in v2}')
398
, sha_string('foo { added in version 1 added in v2 also from v1}')
395
k._sha1s = [sha_string(b'foo {}')
396
, sha_string(b'foo { added in version 1 also from v1}')
397
, sha_string(b'foo { added in v2}')
398
, sha_string(b'foo { added in version 1 added in v2 also from v1}')
399
399
]
400
400
401
401
self.assertEqual(k.get_lines(0),
402
['foo {',
403
'}'])
402
[b'foo {',
403
b'}'])
404
404
405
405
self.assertEqual(k.get_lines(1),
406
['foo {',
407
' added in version 1',
408
' also from v1',
409
'}'])
406
[b'foo {',
407
b' added in version 1',
408
b' also from v1',
409
b'}'])
410
410
411
411
self.assertEqual(k.get_lines(2),
412
['foo {',
413
' added in v2',
414
'}'])
412
[b'foo {',
413
b' added in v2',
414
b'}'])
415
415
416
416
self.assertEqual(k.get_lines(3),
417
['foo {',
418
' added in version 1',
419
' added in v2',
420
' also from v1',
421
'}'])
417
[b'foo {',
418
b' added in version 1',
419
b' added in v2',
420
b' also from v1',
421
b'}'])
422
422
423
423
424
424
class DeleteLines2(TestBase):
429
429
def runTest(self):
430
430
k = Weave()
431
431
432
k.add_lines('text0', [], ["line the first",
433
"line 2",
434
"line 3",
435
"fine"])
432
k.add_lines(b'text0', [], [b"line the first",
433
b"line 2",
434
b"line 3",
435
b"fine"])
436
436
437
437
self.assertEqual(len(k.get_lines(0)), 4)
438
438
439
k.add_lines('text1', ['text0'], ["line the first",
440
"fine"])
439
k.add_lines(b'text1', [b'text0'], [b"line the first",
440
b"fine"])
441
441
442
442
self.assertEqual(k.get_lines(1),
443
["line the first",
444
"fine"])
443
[b"line the first",
444
b"fine"])
445
445
446
self.assertEqual(k.annotate('text1'),
447
[('text0', "line the first"),
448
('text0', "fine")])
446
self.assertEqual(k.annotate(b'text1'),
447
[(b'text0', b"line the first"),
448
(b'text0', b"fine")])
449
449
450
450
451
451
class IncludeVersions(TestBase):
462
462
k = Weave()
463
463
464
464
k._parents = [frozenset(), frozenset([0])]
465
k._weave = [('{', 0),
466
"first line",
467
('}', 0),
468
('{', 1),
469
"second line",
470
('}', 1)]
465
k._weave = [(b'{', 0),
466
b"first line",
467
(b'}', 0),
468
(b'{', 1),
469
b"second line",
470
(b'}', 1)]
471
471
472
k._sha1s = [sha_string('first line')
473
, sha_string('first linesecond line')]
472
k._sha1s = [sha_string(b'first line')
473
, sha_string(b'first linesecond line')]
474
474
475
475
self.assertEqual(k.get_lines(1),
476
["first line",
477
"second line"])
476
[b"first line",
477
b"second line"])
478
478
479
479
self.assertEqual(k.get_lines(0),
480
["first line"])
480
[b"first line"])
481
481
482
482
483
483
class DivergedIncludes(TestBase):
487
487
# FIXME make the weave, dont poke at it.
488
488
k = Weave()
489
489
490
k._names = ['0', '1', '2']
491
k._name_map = {'0':0, '1':1, '2':2}
490
k._names = [b'0', b'1', b'2']
491
k._name_map = {b'0':0, b'1':1, b'2':2}
492
492
k._parents = [frozenset(),
493
493
frozenset([0]),
494
494
frozenset([0]),
495
495
]
496
k._weave = [('{', 0),
497
"first line",
498
('}', 0),
499
('{', 1),
500
"second line",
501
('}', 1),
502
('{', 2),
503
"alternative second line",
504
('}', 2),
496
k._weave = [(b'{', 0),
497
b"first line",
498
(b'}', 0),
499
(b'{', 1),
500
b"second line",
501
(b'}', 1),
502
(b'{', 2),
503
b"alternative second line",
504
(b'}', 2),
505
505
]
506
506
507
k._sha1s = [sha_string('first line')
508
, sha_string('first linesecond line')
509
, sha_string('first linealternative second line')]
507
k._sha1s = [sha_string(b'first line')
508
, sha_string(b'first linesecond line')
509
, sha_string(b'first linealternative second line')]
510
510
511
511
self.assertEqual(k.get_lines(0),
512
["first line"])
512
[b"first line"])
513
513
514
514
self.assertEqual(k.get_lines(1),
515
["first line",
516
"second line"])
517
518
self.assertEqual(k.get_lines('2'),
519
["first line",
520
"alternative second line"])
521
522
self.assertEqual(list(k.get_ancestry(['2'])),
523
['0', '2'])
515
[b"first line",
516
b"second line"])
517
518
self.assertEqual(k.get_lines(b'2'),
519
[b"first line",
520
b"alternative second line"])
521
522
self.assertEqual(list(k.get_ancestry([b'2'])),
523
[b'0', b'2'])
524
524
525
525
526
526
class ReplaceLine(TestBase):
527
527
def runTest(self):
528
528
k = Weave()
529
529
530
text0 = ['cheddar', 'stilton', 'gruyere']
531
text1 = ['cheddar', 'blue vein', 'neufchatel', 'chevre']
530
text0 = [b'cheddar', b'stilton', b'gruyere']
531
text1 = [b'cheddar', b'blue vein', b'neufchatel', b'chevre']
532
532
533
k.add_lines('text0', [], text0)
534
k.add_lines('text1', ['text0'], text1)
533
k.add_lines(b'text0', [], text0)
534
k.add_lines(b'text1', [b'text0'], text1)
535
535
536
536
self.log('k._weave=' + pformat(k._weave))
537
537
545
545
def runTest(self):
546
546
k = Weave()
547
547
548
texts = [['header'],
549
['header', '', 'line from 1'],
550
['header', '', 'line from 2', 'more from 2'],
551
['header', '', 'line from 1', 'fixup line', 'line from 2'],
548
texts = [[b'header'],
549
[b'header', b'', b'line from 1'],
550
[b'header', b'', b'line from 2', b'more from 2'],
551
[b'header', b'', b'line from 1', b'fixup line', b'line from 2'],
552
552
]
553
553
554
k.add_lines('text0', [], texts[0])
555
k.add_lines('text1', ['text0'], texts[1])
556
k.add_lines('text2', ['text0'], texts[2])
557
k.add_lines('merge', ['text0', 'text1', 'text2'], texts[3])
554
k.add_lines(b'text0', [], texts[0])
555
k.add_lines(b'text1', [b'text0'], texts[1])
556
k.add_lines(b'text2', [b'text0'], texts[2])
557
k.add_lines(b'merge', [b'text0', b'text1', b'text2'], texts[3])
558
558
559
559
for i, t in enumerate(texts):
560
560
self.assertEqual(k.get_lines(i), t)
561
561
562
self.assertEqual(k.annotate('merge'),
563
[('text0', 'header'),
564
('text1', ''),
565
('text1', 'line from 1'),
566
('merge', 'fixup line'),
567
('text2', 'line from 2'),
562
self.assertEqual(k.annotate(b'merge'),
563
[(b'text0', b'header'),
564
(b'text1', b''),
565
(b'text1', b'line from 1'),
566
(b'merge', b'fixup line'),
567
(b'text2', b'line from 2'),
568
568
])
569
569
570
self.assertEqual(list(k.get_ancestry(['merge'])),
571
['text0', 'text1', 'text2', 'merge'])
570
self.assertEqual(list(k.get_ancestry([b'merge'])),
571
[b'text0', b'text1', b'text2', b'merge'])
572
572
573
573
self.log('k._weave=' + pformat(k._weave))
574
574
585
585
return # NOT RUN
586
586
k = Weave()
587
587
588
k.add_lines([], ['aaa', 'bbb'])
589
k.add_lines([0], ['aaa', '111', 'bbb'])
590
k.add_lines([1], ['aaa', '222', 'bbb'])
588
k.add_lines([], [b'aaa', b'bbb'])
589
k.add_lines([0], [b'aaa', b'111', b'bbb'])
590
k.add_lines([1], [b'aaa', b'222', b'bbb'])
591
591
592
592
merged = k.merge([1, 2])
593
593
594
self.assertEqual([[['aaa']],
595
[['111'], ['222']],
596
[['bbb']]])
594
self.assertEqual([[[b'aaa']],
595
[[b'111'], [b'222']],
596
[[b'bbb']]])
597
597
598
598
599
599
class NonConflict(TestBase):
604
604
return # NOT RUN
605
605
k = Weave()
606
606
607
k.add_lines([], ['aaa', 'bbb'])
608
k.add_lines([0], ['111', 'aaa', 'ccc', 'bbb'])
609
k.add_lines([1], ['aaa', 'ccc', 'bbb', '222'])
607
k.add_lines([], [b'aaa', b'bbb'])
608
k.add_lines([0], [b'111', b'aaa', b'ccc', b'bbb'])
609
k.add_lines([1], [b'aaa', b'ccc', b'bbb', b'222'])
610
610
611
611
612
612
class Khayyam(TestBase):
614
614
615
615
def test_multi_line_merge(self):
616
616
rawtexts = [
617
"""A Book of Verses underneath the Bough,
617
b"""A Book of Verses underneath the Bough,
618
618
A Jug of Wine, a Loaf of Bread, -- and Thou
619
619
Beside me singing in the Wilderness --
620
620
Oh, Wilderness were Paradise enow!""",
621
621
622
"""A Book of Verses underneath the Bough,
622
b"""A Book of Verses underneath the Bough,
623
623
A Jug of Wine, a Loaf of Bread, -- and Thou
624
624
Beside me singing in the Wilderness --
625
625
Oh, Wilderness were Paradise now!""",
626
626
627
"""A Book of poems underneath the tree,
627
b"""A Book of poems underneath the tree,
628
628
A Jug of Wine, a Loaf of Bread,
629
629
and Thou
630
630
Beside me singing in the Wilderness --
632
632
633
633
-- O. Khayyam""",
634
634
635
"""A Book of Verses underneath the Bough,
635
b"""A Book of Verses underneath the Bough,
636
636
A Jug of Wine, a Loaf of Bread,
637
637
and Thou
638
638
Beside me singing in the Wilderness --
639
639
Oh, Wilderness were Paradise now!""",
640
640
]
641
texts = [[l.strip() for l in t.split('\n')] for t in rawtexts]
641
texts = [[l.strip() for l in t.split(b'\n')] for t in rawtexts]
642
642
643
643
k = Weave()
644
644
parents = set()
645
645
i = 0
646
646
for t in texts:
647
ver = k.add_lines('text%d' % i,
647
ver = k.add_lines(b'text%d' % i,
648
648
list(parents), t)
649
parents.add('text%d' % i)
649
parents.add(b'text%d' % i)
650
650
i += 1
651
651
652
652
self.log("k._weave=" + pformat(k._weave))
662
662
def setUp(self):
663
663
super(JoinWeavesTests, self).setUp()
664
664
self.weave1 = Weave()
665
self.lines1 = ['hello\n']
666
self.lines3 = ['hello\n', 'cruel\n', 'world\n']
667
self.weave1.add_lines('v1', [], self.lines1)
668
self.weave1.add_lines('v2', ['v1'], ['hello\n', 'world\n'])
669
self.weave1.add_lines('v3', ['v2'], self.lines3)
665
self.lines1 = [b'hello\n']
666
self.lines3 = [b'hello\n', b'cruel\n', b'world\n']
667
self.weave1.add_lines(b'v1', [], self.lines1)
668
self.weave1.add_lines(b'v2', [b'v1'], [b'hello\n', b'world\n'])
669
self.weave1.add_lines(b'v3', [b'v2'], self.lines3)
670
670
671
671
def test_written_detection(self):
672
672
# Test detection of weave file corruption.
676
676
# but it at least helps verify the data you get, is what you want.
677
677
678
678
w = Weave()
679
w.add_lines('v1', [], ['hello\n'])
680
w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
679
w.add_lines(b'v1', [], [b'hello\n'])
680
w.add_lines(b'v2', [b'v1'], [b'hello\n', b'there\n'])
681
681
682
682
tmpf = BytesIO()
683
683
write_weave(w, tmpf)
684
684
685
685
# Because we are corrupting, we need to make sure we have the exact text
686
self.assertEqual('# bzr weave file v5\n'
687
'i\n1 f572d396fae9206628714fb2ce00f72e94f2258f\nn v1\n\n'
688
'i 0\n1 90f265c6e75f1c8f9ab76dcf85528352c5f215ef\nn v2\n\n'
689
'w\n{ 0\n. hello\n}\n{ 1\n. there\n}\nW\n',
690
tmpf.getvalue())
686
self.assertEqual(b'# bzr weave file v5\n'
687
b'i\n1 f572d396fae9206628714fb2ce00f72e94f2258f\nn v1\n\n'
688
b'i 0\n1 90f265c6e75f1c8f9ab76dcf85528352c5f215ef\nn v2\n\n'
689
b'w\n{ 0\n. hello\n}\n{ 1\n. there\n}\nW\n',
690
tmpf.getvalue())
691
691
692
692
# Change a single letter
693
693
tmpf = BytesIO(b'# bzr weave file v5\n'
697
697
698
698
w = read_weave(tmpf)
699
699
700
self.assertEqual('hello\n', w.get_text('v1'))
701
self.assertRaises(WeaveInvalidChecksum, w.get_text, 'v2')
702
self.assertRaises(WeaveInvalidChecksum, w.get_lines, 'v2')
700
self.assertEqual(b'hello\n', w.get_text(b'v1'))
701
self.assertRaises(WeaveInvalidChecksum, w.get_text, b'v2')
702
self.assertRaises(WeaveInvalidChecksum, w.get_lines, b'v2')
703
703
self.assertRaises(WeaveInvalidChecksum, w.check)
704
704
705
705
# Change the sha checksum
710
710
711
711
w = read_weave(tmpf)
712
712
713
self.assertEqual('hello\n', w.get_text('v1'))
714
self.assertRaises(WeaveInvalidChecksum, w.get_text, 'v2')
715
self.assertRaises(WeaveInvalidChecksum, w.get_lines, 'v2')
713
self.assertEqual(b'hello\n', w.get_text(b'v1'))
714
self.assertRaises(WeaveInvalidChecksum, w.get_text, b'v2')
715
self.assertRaises(WeaveInvalidChecksum, w.get_lines, b'v2')
716
716
self.assertRaises(WeaveInvalidChecksum, w.check)
717
717
718
718
721
721
def test_allow_reserved_false(self):
722
722
w = Weave('name', allow_reserved=False)
723
723
# Add lines is checked at the WeaveFile level, not at the Weave level
724
w.add_lines('name:', [], TEXT_1)
724
w.add_lines(b'name:', [], TEXT_1)
725
725
# But get_lines is checked at this level
726
self.assertRaises(errors.ReservedId, w.get_lines, 'name:')
726
self.assertRaises(errors.ReservedId, w.get_lines, b'name:')
727
727
728
728
def test_allow_reserved_true(self):
729
729
w = Weave('name', allow_reserved=True)
730
w.add_lines('name:', [], TEXT_1)
731
self.assertEqual(TEXT_1, w.get_lines('name:'))
730
w.add_lines(b'name:', [], TEXT_1)
731
self.assertEqual(TEXT_1, w.get_lines(b'name:'))
732
732
733
733
734
734
class InstrumentedWeave(Weave):
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0