/brz/remove-bazaar

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_inventory_delta.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-16 19:47:19 UTC
  • mfrom: (7178 work)
  • mto: This revision was merged to the branch mainline in revision 7179.
  • Revision ID: jelmer@jelmer.uk-20181116194719-m5ut2wfuze5x9s1p
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_inventory_delta.py
102
102
    def test_parse_bad_format(self):
103
103
        deserializer = inventory_delta.InventoryDeltaDeserializer()
104
104
        err = self.assertRaises(InventoryDeltaError,
105
 
            deserializer.parse_text_bytes, b'format: foo\n')
 
105
                                deserializer.parse_text_bytes, b'format: foo\n')
106
106
        self.assertContainsRe(str(err), 'unknown format')
107
107
 
108
108
    def test_parse_no_parent(self):
109
109
        deserializer = inventory_delta.InventoryDeltaDeserializer()
110
110
        err = self.assertRaises(InventoryDeltaError,
111
 
            deserializer.parse_text_bytes,
112
 
            b'format: bzr inventory delta v1 (bzr 1.14)\n')
 
111
                                deserializer.parse_text_bytes,
 
112
                                b'format: bzr inventory delta v1 (bzr 1.14)\n')
113
113
        self.assertContainsRe(str(err), 'missing parent: marker')
114
114
 
115
115
    def test_parse_no_version(self):
116
116
        deserializer = inventory_delta.InventoryDeltaDeserializer()
117
117
        err = self.assertRaises(InventoryDeltaError,
118
 
            deserializer.parse_text_bytes,
119
 
            b'format: bzr inventory delta v1 (bzr 1.14)\n'
120
 
            b'parent: null:\n')
 
118
                                deserializer.parse_text_bytes,
 
119
                                b'format: bzr inventory delta v1 (bzr 1.14)\n'
 
120
                                b'parent: null:\n')
121
121
        self.assertContainsRe(str(err), 'missing version: marker')
122
122
 
123
123
    def test_parse_duplicate_key_errors(self):
124
124
        deserializer = inventory_delta.InventoryDeltaDeserializer()
125
125
        double_root_lines = \
126
 
b"""format: bzr inventory delta v1 (bzr 1.14)
 
126
            b"""format: bzr inventory delta v1 (bzr 1.14)
127
127
parent: null:
128
128
version: null:
129
129
versioned_root: true
132
132
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
133
133
"""
134
134
        err = self.assertRaises(InventoryDeltaError,
135
 
            deserializer.parse_text_bytes, double_root_lines)
 
135
                                deserializer.parse_text_bytes, double_root_lines)
136
136
        self.assertContainsRe(str(err), 'duplicate file id')
137
137
 
138
138
    def test_parse_versioned_root_only(self):
156
156
None\x00/\x00TREE_ROOT\x00\x00null:\x00dir\x00\x00
157
157
"""
158
158
        err = self.assertRaises(InventoryDeltaError,
159
 
            deserializer.parse_text_bytes, root_only_lines)
 
159
                                deserializer.parse_text_bytes, root_only_lines)
160
160
        self.assertContainsRe(str(err), 'special revisionid found')
161
161
 
162
162
    def test_parse_versioned_root_versioned_disabled(self):
169
169
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
170
170
"""
171
171
        err = self.assertRaises(InventoryDeltaError,
172
 
            deserializer.parse_text_bytes, root_only_lines)
 
172
                                deserializer.parse_text_bytes, root_only_lines)
173
173
        self.assertContainsRe(str(err), 'Versioned root found')
174
174
 
175
175
    def test_parse_unique_root_id_root_versioned_disabled(self):
182
182
None\x00/\x00an-id\x00\x00parent-id\x00dir\x00\x00
183
183
"""
184
184
        err = self.assertRaises(InventoryDeltaError,
185
 
            deserializer.parse_text_bytes, root_only_lines)
 
185
                                deserializer.parse_text_bytes, root_only_lines)
186
186
        self.assertContainsRe(str(err), 'Versioned root found')
187
187
 
188
188
    def test_parse_unversioned_root_versioning_enabled(self):
200
200
        deserializer = inventory_delta.InventoryDeltaDeserializer(
201
201
            allow_versioned_root=False)
202
202
        err = self.assertRaises(inventory_delta.IncompatibleInventoryDelta,
203
 
            deserializer.parse_text_bytes, root_only_lines)
 
203
                                deserializer.parse_text_bytes, root_only_lines)
204
204
        self.assertEqual("versioned_root not allowed", str(err))
205
205
 
206
206
    def test_parse_tree_when_disabled(self):
207
207
        deserializer = inventory_delta.InventoryDeltaDeserializer(
208
208
            allow_tree_references=False)
209
209
        err = self.assertRaises(inventory_delta.IncompatibleInventoryDelta,
210
 
            deserializer.parse_text_bytes, reference_lines)
 
210
                                deserializer.parse_text_bytes, reference_lines)
211
211
        self.assertEqual("Tree reference not allowed", str(err))
212
212
 
213
213
    def test_parse_tree_when_header_disallows(self):
223
223
None\x00/foo\x00id\x00TREE_ROOT\x00changed\x00tree\x00subtree-version
224
224
"""
225
225
        err = self.assertRaises(InventoryDeltaError,
226
 
            deserializer.parse_text_bytes, lines)
 
226
                                deserializer.parse_text_bytes, lines)
227
227
        self.assertContainsRe(str(err), 'Tree reference found')
228
228
 
229
229
    def test_parse_versioned_root_when_header_disallows(self):
239
239
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir
240
240
"""
241
241
        err = self.assertRaises(InventoryDeltaError,
242
 
            deserializer.parse_text_bytes, lines)
 
242
                                deserializer.parse_text_bytes, lines)
243
243
        self.assertContainsRe(str(err), 'Versioned root found')
244
244
 
245
245
    def test_parse_last_line_not_empty(self):
248
248
        lines = root_only_lines[:-1]
249
249
        deserializer = inventory_delta.InventoryDeltaDeserializer()
250
250
        err = self.assertRaises(InventoryDeltaError,
251
 
            deserializer.parse_text_bytes, lines)
 
251
                                deserializer.parse_text_bytes, lines)
252
252
        self.assertContainsRe(str(err), 'last line not empty')
253
253
 
254
254
    def test_parse_invalid_newpath(self):
257
257
        lines += b"None\x00bad\x00TREE_ROOT\x00\x00version\x00dir\n"
258
258
        deserializer = inventory_delta.InventoryDeltaDeserializer()
259
259
        err = self.assertRaises(InventoryDeltaError,
260
 
            deserializer.parse_text_bytes, lines)
 
260
                                deserializer.parse_text_bytes, lines)
261
261
        self.assertContainsRe(str(err), 'newpath invalid')
262
262
 
263
263
    def test_parse_invalid_oldpath(self):
266
266
        lines += b"bad\x00/new\x00file-id\x00\x00version\x00dir\n"
267
267
        deserializer = inventory_delta.InventoryDeltaDeserializer()
268
268
        err = self.assertRaises(InventoryDeltaError,
269
 
            deserializer.parse_text_bytes, lines)
 
269
                                deserializer.parse_text_bytes, lines)
270
270
        self.assertContainsRe(str(err), 'oldpath invalid')
271
271
 
272
272
    def test_parse_new_file(self):
285
285
        expected_entry.text_sha1 = fake_sha
286
286
        delta = parse_result[4]
287
287
        self.assertEqual(
288
 
             (None, u'new', b'file-id', expected_entry), delta[-1])
 
288
            (None, u'new', b'file-id', expected_entry), delta[-1])
289
289
 
290
290
    def test_parse_delete(self):
291
291
        lines = root_only_lines
295
295
        parse_result = deserializer.parse_text_bytes(lines)
296
296
        delta = parse_result[4]
297
297
        self.assertEqual(
298
 
             (u'old-file', None, b'deleted-id', None), delta[-1])
 
298
            (u'old-file', None, b'deleted-id', None), delta[-1])
299
299
 
300
300
 
301
301
class TestSerialization(TestCase):
308
308
        serializer = inventory_delta.InventoryDeltaSerializer(
309
309
            versioned_root=True, tree_references=True)
310
310
        self.assertEqual(BytesIO(empty_lines).readlines(),
311
 
            serializer.delta_to_lines(NULL_REVISION, NULL_REVISION, delta))
 
311
                         serializer.delta_to_lines(NULL_REVISION, NULL_REVISION, delta))
312
312
 
313
313
    def test_root_only_to_lines(self):
314
314
        old_inv = Inventory(None)
320
320
        serializer = inventory_delta.InventoryDeltaSerializer(
321
321
            versioned_root=True, tree_references=True)
322
322
        self.assertEqual(BytesIO(root_only_lines).readlines(),
323
 
            serializer.delta_to_lines(NULL_REVISION, b'entry-version', delta))
 
323
                         serializer.delta_to_lines(NULL_REVISION, b'entry-version', delta))
324
324
 
325
325
    def test_unversioned_root(self):
326
326
        old_inv = Inventory(None)
335
335
        serialized_lines = serializer.delta_to_lines(
336
336
            NULL_REVISION, b'entry-version', delta)
337
337
        self.assertEqual(BytesIO(root_only_unversioned).readlines(),
338
 
            serialized_lines)
 
338
                         serialized_lines)
339
339
        deserializer = inventory_delta.InventoryDeltaDeserializer()
340
340
        self.assertEqual(
341
341
            (NULL_REVISION, b'entry-version', False, False, delta),
353
353
        serializer = inventory_delta.InventoryDeltaSerializer(
354
354
            versioned_root=True, tree_references=True)
355
355
        err = self.assertRaises(InventoryDeltaError,
356
 
            serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
 
356
                                serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
357
357
        self.assertContainsRe(str(err), "^no version for fileid b?'id'$")
358
358
 
359
359
    def test_richroot_unversioned_root_errors(self):
365
365
        serializer = inventory_delta.InventoryDeltaSerializer(
366
366
            versioned_root=True, tree_references=True)
367
367
        err = self.assertRaises(InventoryDeltaError,
368
 
            serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
 
368
                                serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
369
369
        self.assertContainsRe(
370
370
            str(err), "no version for fileid b?'TREE_ROOT'$")
371
371
 
379
379
        serializer = inventory_delta.InventoryDeltaSerializer(
380
380
            versioned_root=False, tree_references=True)
381
381
        err = self.assertRaises(InventoryDeltaError,
382
 
            serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
 
382
                                serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
383
383
        self.assertContainsRe(
384
384
            str(err), "^Version present for / in b?'TREE_ROOT'")
385
385
 
389
389
        root = new_inv.make_entry('directory', u'', None, b'my-rich-root-id')
390
390
        root.revision = b'changed'
391
391
        new_inv.add(root)
 
392
 
392
393
        class StrangeInventoryEntry(inventory.InventoryEntry):
393
394
            kind = 'strange'
394
395
        non_root = StrangeInventoryEntry(b'id', u'foo', root.file_id)
400
401
        # we expect keyerror because there is little value wrapping this.
401
402
        # This test aims to prove that it errors more than how it errors.
402
403
        err = self.assertRaises(KeyError,
403
 
            serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
 
404
                                serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
404
405
        self.assertEqual(('strange',), err.args)
405
406
 
406
407
    def test_tree_reference_disabled(self):
420
421
        # we expect keyerror because there is little value wrapping this.
421
422
        # This test aims to prove that it errors more than how it errors.
422
423
        err = self.assertRaises(KeyError,
423
 
            serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
 
424
                                serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
424
425
        self.assertEqual(('tree-reference',), err.args)
425
426
 
426
427
    def test_tree_reference_enabled(self):
438
439
        serializer = inventory_delta.InventoryDeltaSerializer(
439
440
            versioned_root=True, tree_references=True)
440
441
        self.assertEqual(BytesIO(reference_lines).readlines(),
441
 
            serializer.delta_to_lines(NULL_REVISION, b'entry-version', delta))
 
442
                         serializer.delta_to_lines(NULL_REVISION, b'entry-version', delta))
442
443
 
443
444
    def test_to_inventory_root_id_versioned_not_permitted(self):
444
445
        root_entry = inventory.make_entry('directory', u'', None, b'TREE_ROOT')
473
474
        serializer = inventory_delta.InventoryDeltaSerializer(
474
475
            versioned_root=True, tree_references=True)
475
476
        self.assertRaises(InventoryDeltaError, serializer.delta_to_lines,
476
 
            b'old-version', b'new-version', delta)
 
477
                          b'old-version', b'new-version', delta)
477
478
 
478
479
    def test_to_inventory_torture(self):
479
480
        def make_entry(kind, name, parent_id, file_id, **attrs):
491
492
            # new root:
492
493
            (None, u'', b'new-root-id',
493
494
                make_entry('directory', u'', None, b'new-root-id',
494
 
                    revision=b'changed-in')),
 
495
                           revision=b'changed-in')),
495
496
            # an old root:
496
497
            (u'', u'old-root', b'TREE_ROOT',
497
498
                make_entry('directory', u'subdir-now', b'new-root-id',
498
 
                b'TREE_ROOT', revision=b'moved-root')),
 
499
                           b'TREE_ROOT', revision=b'moved-root')),
499
500
            # a file that followed the root move
500
501
            (u'under-old-root', u'old-root/under-old-root', b'moved-id',
501
502
                make_entry('file', u'under-old-root', b'TREE_ROOT',
502
 
                    b'moved-id', revision=b'old-rev', executable=False,
503
 
                    text_size=30, text_sha1=b'some-sha')),
 
503
                           b'moved-id', revision=b'old-rev', executable=False,
 
504
                           text_size=30, text_sha1=b'some-sha')),
504
505
            # a deleted path
505
506
            (u'old-file', None, b'deleted-id', None),
506
507
            # a tree reference moved to the new root
507
508
            (u'ref', u'ref', b'ref-id',
508
509
                make_entry('tree-reference', u'ref', b'new-root-id', b'ref-id',
509
 
                    reference_revision=b'tree-reference-id',
510
 
                    revision=b'new-rev')),
 
510
                           reference_revision=b'tree-reference-id',
 
511
                           revision=b'new-rev')),
511
512
            # a symlink now in a deep dir
512
513
            (u'dir/link', u'old-root/dir/link', b'link-id',
513
514
                make_entry('symlink', u'link', b'deep-id', b'link-id',
514
 
                   symlink_target=u'target', revision=b'new-rev')),
 
515
                           symlink_target=u'target', revision=b'new-rev')),
515
516
            # a deep dir
516
517
            (u'dir', u'old-root/dir', b'deep-id',
517
518
                make_entry('directory', u'dir', b'TREE_ROOT', b'deep-id',
518
 
                    revision=b'new-rev')),
 
519
                           revision=b'new-rev')),
519
520
            # a file with an exec bit set
520
521
            (None, u'configure', b'exec-id',
521
522
                make_entry('file', u'configure', b'new-root-id', b'exec-id',
522
 
                   executable=True, text_size=30, text_sha1=b'some-sha',
523
 
                   revision=b'old-rev')),
 
523
                           executable=True, text_size=30, text_sha1=b'some-sha',
 
524
                           revision=b'old-rev')),
524
525
            ]
525
526
        serializer = inventory_delta.InventoryDeltaSerializer(
526
527
            versioned_root=True, tree_references=True)
556
557
        file_entry.text_sha1 = b''
557
558
        file_entry.text_size = 0
558
559
        self.assertEqual(b'file\x000\x00\x00',
559
 
            inventory_delta._file_content(file_entry))
 
560
                         inventory_delta._file_content(file_entry))
560
561
 
561
562
    def test_file_10_foo(self):
562
563
        file_entry = inventory.make_entry('file', u'a file', None, b'file-id')
563
564
        file_entry.text_sha1 = b'foo'
564
565
        file_entry.text_size = 10
565
566
        self.assertEqual(b'file\x0010\x00\x00foo',
566
 
            inventory_delta._file_content(file_entry))
 
567
                         inventory_delta._file_content(file_entry))
567
568
 
568
569
    def test_file_executable(self):
569
570
        file_entry = inventory.make_entry('file', u'a file', None, b'file-id')
571
572
        file_entry.text_sha1 = b'foo'
572
573
        file_entry.text_size = 10
573
574
        self.assertEqual(b'file\x0010\x00Y\x00foo',
574
 
            inventory_delta._file_content(file_entry))
 
575
                         inventory_delta._file_content(file_entry))
575
576
 
576
577
    def test_file_without_size(self):
577
578
        file_entry = inventory.make_entry('file', u'a file', None, b'file-id')
578
579
        file_entry.text_sha1 = b'foo'
579
580
        self.assertRaises(InventoryDeltaError,
580
 
            inventory_delta._file_content, file_entry)
 
581
                          inventory_delta._file_content, file_entry)
581
582
 
582
583
    def test_file_without_sha1(self):
583
584
        file_entry = inventory.make_entry('file', u'a file', None, b'file-id')
584
585
        file_entry.text_size = 10
585
586
        self.assertRaises(InventoryDeltaError,
586
 
            inventory_delta._file_content, file_entry)
 
587
                          inventory_delta._file_content, file_entry)
587
588
 
588
589
    def test_link_empty_target(self):
589
590
        entry = inventory.make_entry('symlink', u'a link', None)
590
591
        entry.symlink_target = u''
591
592
        self.assertEqual(b'link\x00',
592
 
            inventory_delta._link_content(entry))
 
593
                         inventory_delta._link_content(entry))
593
594
 
594
595
    def test_link_unicode_target(self):
595
596
        entry = inventory.make_entry('symlink', u'a link', None)
596
597
        entry.symlink_target = b' \xc3\xa5'.decode('utf8')
597
598
        self.assertEqual(b'link\x00 \xc3\xa5',
598
 
            inventory_delta._link_content(entry))
 
599
                         inventory_delta._link_content(entry))
599
600
 
600
601
    def test_link_space_target(self):
601
602
        entry = inventory.make_entry('symlink', u'a link', None)
602
603
        entry.symlink_target = u' '
603
604
        self.assertEqual(b'link\x00 ',
604
 
            inventory_delta._link_content(entry))
 
605
                         inventory_delta._link_content(entry))
605
606
 
606
607
    def test_link_no_target(self):
607
608
        entry = inventory.make_entry('symlink', u'a link', None)
608
609
        self.assertRaises(InventoryDeltaError,
609
 
            inventory_delta._link_content, entry)
 
610
                          inventory_delta._link_content, entry)
610
611
 
611
612
    def test_reference_null(self):
612
613
        entry = inventory.make_entry('tree-reference', u'a tree', None)
613
614
        entry.reference_revision = NULL_REVISION
614
615
        self.assertEqual(b'tree\x00null:',
615
 
            inventory_delta._reference_content(entry))
 
616
                         inventory_delta._reference_content(entry))
616
617
 
617
618
    def test_reference_revision(self):
618
619
        entry = inventory.make_entry('tree-reference', u'a tree', None)
619
620
        entry.reference_revision = b'foo@\xc3\xa5b-lah'
620
621
        self.assertEqual(b'tree\x00foo@\xc3\xa5b-lah',
621
 
            inventory_delta._reference_content(entry))
 
622
                         inventory_delta._reference_content(entry))
622
623
 
623
624
    def test_reference_no_reference(self):
624
625
        entry = inventory.make_entry('tree-reference', u'a tree', None)
625
626
        self.assertRaises(InventoryDeltaError,
626
 
            inventory_delta._reference_content, entry)
 
627
                          inventory_delta._reference_content, entry)