/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 bzrlib/tests/test_inventory_delta.py

  • Committer: Martin Pool
  • Date: 2009-08-28 04:13:16 UTC
  • mfrom: (4634.6.8 2.0)
  • mto: This revision was merged to the branch mainline in revision 4660.
  • Revision ID: mbp@sourcefrog.net-20090828041316-adcbxfnfpc4bjtpl
Merge 2.0 back to trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_inventory_delta.py
26
26
    inventory,
27
27
    inventory_delta,
28
28
    )
 
29
from bzrlib.inventory_delta import InventoryDeltaError
29
30
from bzrlib.inventory import Inventory
30
31
from bzrlib.revision import NULL_REVISION
31
32
from bzrlib.tests import TestCase
68
69
version: entry-version
69
70
versioned_root: false
70
71
tree_references: false
71
 
None\x00/\x00TREE_ROOT\x00\x00null:\x00dir
 
72
None\x00/\x00TREE_ROOT\x00\x00entry-version\x00dir
72
73
"""
73
74
 
74
75
reference_lines = """format: bzr inventory delta v1 (bzr 1.14)
93
94
    """Test InventoryDeltaSerializer.parse_text_bytes."""
94
95
 
95
96
    def test_parse_no_bytes(self):
96
 
        serializer = inventory_delta.InventoryDeltaSerializer(
97
 
            versioned_root=True, tree_references=True)
 
97
        deserializer = inventory_delta.InventoryDeltaDeserializer()
98
98
        err = self.assertRaises(
99
 
            errors.BzrError, serializer.parse_text_bytes, '')
100
 
        self.assertContainsRe(str(err), 'unknown format')
 
99
            InventoryDeltaError, deserializer.parse_text_bytes, '')
 
100
        self.assertContainsRe(str(err), 'last line not empty')
101
101
 
102
102
    def test_parse_bad_format(self):
103
 
        serializer = inventory_delta.InventoryDeltaSerializer(
104
 
            versioned_root=True, tree_references=True)
105
 
        err = self.assertRaises(errors.BzrError,
106
 
            serializer.parse_text_bytes, 'format: foo\n')
 
103
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
104
        err = self.assertRaises(InventoryDeltaError,
 
105
            deserializer.parse_text_bytes, 'format: foo\n')
107
106
        self.assertContainsRe(str(err), 'unknown format')
108
107
 
109
108
    def test_parse_no_parent(self):
110
 
        serializer = inventory_delta.InventoryDeltaSerializer(
111
 
            versioned_root=True, tree_references=True)
112
 
        err = self.assertRaises(errors.BzrError,
113
 
            serializer.parse_text_bytes,
 
109
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
110
        err = self.assertRaises(InventoryDeltaError,
 
111
            deserializer.parse_text_bytes,
114
112
            'format: bzr inventory delta v1 (bzr 1.14)\n')
115
113
        self.assertContainsRe(str(err), 'missing parent: marker')
116
114
 
117
115
    def test_parse_no_version(self):
118
 
        serializer = inventory_delta.InventoryDeltaSerializer(
119
 
            versioned_root=True, tree_references=True)
120
 
        err = self.assertRaises(errors.BzrError,
121
 
            serializer.parse_text_bytes,
 
116
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
117
        err = self.assertRaises(InventoryDeltaError,
 
118
            deserializer.parse_text_bytes,
122
119
            'format: bzr inventory delta v1 (bzr 1.14)\n'
123
120
            'parent: null:\n')
124
121
        self.assertContainsRe(str(err), 'missing version: marker')
125
122
            
126
123
    def test_parse_duplicate_key_errors(self):
127
 
        serializer = inventory_delta.InventoryDeltaSerializer(
128
 
            versioned_root=True, tree_references=True)
 
124
        deserializer = inventory_delta.InventoryDeltaDeserializer()
129
125
        double_root_lines = \
130
126
"""format: bzr inventory delta v1 (bzr 1.14)
131
127
parent: null:
135
131
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
136
132
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
137
133
"""
138
 
        err = self.assertRaises(errors.BzrError,
139
 
            serializer.parse_text_bytes, double_root_lines)
 
134
        err = self.assertRaises(InventoryDeltaError,
 
135
            deserializer.parse_text_bytes, double_root_lines)
140
136
        self.assertContainsRe(str(err), 'duplicate file id')
141
137
 
142
138
    def test_parse_versioned_root_only(self):
143
 
        serializer = inventory_delta.InventoryDeltaSerializer(
144
 
            versioned_root=True, tree_references=True)
145
 
        parse_result = serializer.parse_text_bytes(root_only_lines)
 
139
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
140
        parse_result = deserializer.parse_text_bytes(root_only_lines)
146
141
        expected_entry = inventory.make_entry(
147
142
            'directory', u'', None, 'an-id')
148
143
        expected_entry.revision = 'a@e\xc3\xa5ample.com--2004'
149
144
        self.assertEqual(
150
 
            ('null:', 'entry-version', [(None, '/', 'an-id', expected_entry)]),
 
145
            ('null:', 'entry-version', True, True,
 
146
             [(None, '', 'an-id', expected_entry)]),
151
147
            parse_result)
152
148
 
153
149
    def test_parse_special_revid_not_valid_last_mod(self):
154
 
        serializer = inventory_delta.InventoryDeltaSerializer(
155
 
            versioned_root=False, tree_references=True)
 
150
        deserializer = inventory_delta.InventoryDeltaDeserializer()
156
151
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
157
152
parent: null:
158
153
version: null:
160
155
tree_references: true
161
156
None\x00/\x00TREE_ROOT\x00\x00null:\x00dir\x00\x00
162
157
"""
163
 
        err = self.assertRaises(errors.BzrError,
164
 
            serializer.parse_text_bytes, root_only_lines)
 
158
        err = self.assertRaises(InventoryDeltaError,
 
159
            deserializer.parse_text_bytes, root_only_lines)
165
160
        self.assertContainsRe(str(err), 'special revisionid found')
166
161
 
167
162
    def test_parse_versioned_root_versioned_disabled(self):
168
 
        serializer = inventory_delta.InventoryDeltaSerializer(
169
 
            versioned_root=False, tree_references=True)
 
163
        deserializer = inventory_delta.InventoryDeltaDeserializer()
170
164
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
171
165
parent: null:
172
166
version: null:
174
168
tree_references: true
175
169
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
176
170
"""
177
 
        err = self.assertRaises(errors.BzrError,
178
 
            serializer.parse_text_bytes, root_only_lines)
 
171
        err = self.assertRaises(InventoryDeltaError,
 
172
            deserializer.parse_text_bytes, root_only_lines)
179
173
        self.assertContainsRe(str(err), 'Versioned root found')
180
174
 
181
175
    def test_parse_unique_root_id_root_versioned_disabled(self):
182
 
        serializer = inventory_delta.InventoryDeltaSerializer(
183
 
            versioned_root=False, tree_references=True)
 
176
        deserializer = inventory_delta.InventoryDeltaDeserializer()
184
177
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
185
 
parent: null:
186
 
version: null:
 
178
parent: parent-id
 
179
version: a@e\xc3\xa5ample.com--2004
187
180
versioned_root: false
188
181
tree_references: true
189
 
None\x00/\x00an-id\x00\x00null:\x00dir\x00\x00
 
182
None\x00/\x00an-id\x00\x00parent-id\x00dir\x00\x00
190
183
"""
191
 
        err = self.assertRaises(errors.BzrError,
192
 
            serializer.parse_text_bytes, root_only_lines)
 
184
        err = self.assertRaises(InventoryDeltaError,
 
185
            deserializer.parse_text_bytes, root_only_lines)
193
186
        self.assertContainsRe(str(err), 'Versioned root found')
194
187
 
195
188
    def test_parse_unversioned_root_versioning_enabled(self):
196
 
        serializer = inventory_delta.InventoryDeltaSerializer(
197
 
            versioned_root=True, tree_references=True)
198
 
        err = self.assertRaises(errors.BzrError,
199
 
            serializer.parse_text_bytes, root_only_unversioned)
200
 
        self.assertContainsRe(
201
 
            str(err), 'serialized versioned_root flag is wrong: False')
 
189
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
190
        parse_result = deserializer.parse_text_bytes(root_only_unversioned)
 
191
        expected_entry = inventory.make_entry(
 
192
            'directory', u'', None, 'TREE_ROOT')
 
193
        expected_entry.revision = 'entry-version'
 
194
        self.assertEqual(
 
195
            ('null:', 'entry-version', False, False,
 
196
             [(None, u'', 'TREE_ROOT', expected_entry)]),
 
197
            parse_result)
 
198
 
 
199
    def test_parse_versioned_root_when_disabled(self):
 
200
        deserializer = inventory_delta.InventoryDeltaDeserializer(
 
201
            allow_versioned_root=False)
 
202
        err = self.assertRaises(inventory_delta.IncompatibleInventoryDelta,
 
203
            deserializer.parse_text_bytes, root_only_lines)
 
204
        self.assertEquals("versioned_root not allowed", str(err))
202
205
 
203
206
    def test_parse_tree_when_disabled(self):
204
 
        serializer = inventory_delta.InventoryDeltaSerializer(
205
 
            versioned_root=True, tree_references=False)
206
 
        err = self.assertRaises(errors.BzrError,
207
 
            serializer.parse_text_bytes, reference_lines)
208
 
        self.assertContainsRe(
209
 
            str(err), 'serialized tree_references flag is wrong: True')
 
207
        deserializer = inventory_delta.InventoryDeltaDeserializer(
 
208
            allow_tree_references=False)
 
209
        err = self.assertRaises(inventory_delta.IncompatibleInventoryDelta,
 
210
            deserializer.parse_text_bytes, reference_lines)
 
211
        self.assertEquals("Tree reference not allowed", str(err))
 
212
 
 
213
    def test_parse_tree_when_header_disallows(self):
 
214
        # A deserializer that allows tree_references to be set or unset.
 
215
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
216
        # A serialised inventory delta with a header saying no tree refs, but
 
217
        # that has a tree ref in its content.
 
218
        lines = """format: bzr inventory delta v1 (bzr 1.14)
 
219
parent: null:
 
220
version: entry-version
 
221
versioned_root: false
 
222
tree_references: false
 
223
None\x00/foo\x00id\x00TREE_ROOT\x00changed\x00tree\x00subtree-version
 
224
"""
 
225
        err = self.assertRaises(InventoryDeltaError,
 
226
            deserializer.parse_text_bytes, lines)
 
227
        self.assertContainsRe(str(err), 'Tree reference found')
 
228
 
 
229
    def test_parse_versioned_root_when_header_disallows(self):
 
230
        # A deserializer that allows tree_references to be set or unset.
 
231
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
232
        # A serialised inventory delta with a header saying no tree refs, but
 
233
        # that has a tree ref in its content.
 
234
        lines = """format: bzr inventory delta v1 (bzr 1.14)
 
235
parent: null:
 
236
version: entry-version
 
237
versioned_root: false
 
238
tree_references: false
 
239
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir
 
240
"""
 
241
        err = self.assertRaises(InventoryDeltaError,
 
242
            deserializer.parse_text_bytes, lines)
 
243
        self.assertContainsRe(str(err), 'Versioned root found')
 
244
 
 
245
    def test_parse_last_line_not_empty(self):
 
246
        """newpath must start with / if it is not None."""
 
247
        # Trim the trailing newline from a valid serialization
 
248
        lines = root_only_lines[:-1]
 
249
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
250
        err = self.assertRaises(InventoryDeltaError,
 
251
            deserializer.parse_text_bytes, lines)
 
252
        self.assertContainsRe(str(err), 'last line not empty')
 
253
 
 
254
    def test_parse_invalid_newpath(self):
 
255
        """newpath must start with / if it is not None."""
 
256
        lines = empty_lines
 
257
        lines += "None\x00bad\x00TREE_ROOT\x00\x00version\x00dir\n"
 
258
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
259
        err = self.assertRaises(InventoryDeltaError,
 
260
            deserializer.parse_text_bytes, lines)
 
261
        self.assertContainsRe(str(err), 'newpath invalid')
 
262
 
 
263
    def test_parse_invalid_oldpath(self):
 
264
        """oldpath must start with / if it is not None."""
 
265
        lines = root_only_lines
 
266
        lines += "bad\x00/new\x00file-id\x00\x00version\x00dir\n"
 
267
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
268
        err = self.assertRaises(InventoryDeltaError,
 
269
            deserializer.parse_text_bytes, lines)
 
270
        self.assertContainsRe(str(err), 'oldpath invalid')
 
271
    
 
272
    def test_parse_new_file(self):
 
273
        """a new file is parsed correctly"""
 
274
        lines = root_only_lines
 
275
        fake_sha = "deadbeef" * 5
 
276
        lines += (
 
277
            "None\x00/new\x00file-id\x00an-id\x00version\x00file\x00123\x00" +
 
278
            "\x00" + fake_sha + "\n")
 
279
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
280
        parse_result = deserializer.parse_text_bytes(lines)
 
281
        expected_entry = inventory.make_entry(
 
282
            'file', u'new', 'an-id', 'file-id')
 
283
        expected_entry.revision = 'version'
 
284
        expected_entry.text_size = 123
 
285
        expected_entry.text_sha1 = fake_sha
 
286
        delta = parse_result[4]
 
287
        self.assertEqual(
 
288
             (None, u'new', 'file-id', expected_entry), delta[-1])
 
289
 
 
290
    def test_parse_delete(self):
 
291
        lines = root_only_lines
 
292
        lines += (
 
293
            "/old-file\x00None\x00deleted-id\x00\x00null:\x00deleted\x00\x00\n")
 
294
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
295
        parse_result = deserializer.parse_text_bytes(lines)
 
296
        delta = parse_result[4]
 
297
        self.assertEqual(
 
298
             (u'old-file', None, 'deleted-id', None), delta[-1])
210
299
 
211
300
 
212
301
class TestSerialization(TestCase):
237
326
        old_inv = Inventory(None)
238
327
        new_inv = Inventory(None)
239
328
        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
 
329
        # Implicit roots are considered modified in every revision.
 
330
        root.revision = 'entry-version'
240
331
        new_inv.add(root)
241
332
        delta = new_inv._make_delta(old_inv)
242
333
        serializer = inventory_delta.InventoryDeltaSerializer(
243
334
            versioned_root=False, tree_references=False)
 
335
        serialized_lines = serializer.delta_to_lines(
 
336
            NULL_REVISION, 'entry-version', delta)
244
337
        self.assertEqual(StringIO(root_only_unversioned).readlines(),
245
 
            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
 
338
            serialized_lines)
 
339
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
340
        self.assertEqual(
 
341
            (NULL_REVISION, 'entry-version', False, False, delta),
 
342
            deserializer.parse_text_bytes(''.join(serialized_lines)))
246
343
 
247
344
    def test_unversioned_non_root_errors(self):
248
345
        old_inv = Inventory(None)
255
352
        delta = new_inv._make_delta(old_inv)
256
353
        serializer = inventory_delta.InventoryDeltaSerializer(
257
354
            versioned_root=True, tree_references=True)
258
 
        err = self.assertRaises(errors.BzrError,
 
355
        err = self.assertRaises(InventoryDeltaError,
259
356
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
260
357
        self.assertEqual(str(err), 'no version for fileid id')
261
358
 
267
364
        delta = new_inv._make_delta(old_inv)
268
365
        serializer = inventory_delta.InventoryDeltaSerializer(
269
366
            versioned_root=True, tree_references=True)
270
 
        err = self.assertRaises(errors.BzrError,
 
367
        err = self.assertRaises(InventoryDeltaError,
271
368
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
272
369
        self.assertEqual(str(err), 'no version for fileid TREE_ROOT')
273
370
 
280
377
        delta = new_inv._make_delta(old_inv)
281
378
        serializer = inventory_delta.InventoryDeltaSerializer(
282
379
            versioned_root=False, tree_references=True)
283
 
        err = self.assertRaises(errors.BzrError,
284
 
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
285
 
        self.assertEqual(str(err), 'Version present for / in TREE_ROOT')
286
 
 
287
 
    def test_nonrichroot_non_TREE_ROOT_id_errors(self):
288
 
        old_inv = Inventory(None)
289
 
        new_inv = Inventory(None)
290
 
        root = new_inv.make_entry('directory', '', None, 'my-rich-root-id')
291
 
        new_inv.add(root)
292
 
        delta = new_inv._make_delta(old_inv)
293
 
        serializer = inventory_delta.InventoryDeltaSerializer(
294
 
            versioned_root=False, tree_references=True)
295
 
        err = self.assertRaises(errors.BzrError,
296
 
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
297
 
        self.assertEqual(
298
 
            str(err), 'file_id my-rich-root-id is not TREE_ROOT for /')
 
380
        err = self.assertRaises(InventoryDeltaError,
 
381
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
 
382
        self.assertStartsWith(str(err), 'Version present for / in TREE_ROOT')
299
383
 
300
384
    def test_unknown_kind_errors(self):
301
385
        old_inv = Inventory(None)
354
438
            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
355
439
 
356
440
    def test_to_inventory_root_id_versioned_not_permitted(self):
357
 
        delta = [(None, '/', 'TREE_ROOT', inventory.make_entry(
358
 
            'directory', '', None, 'TREE_ROOT'))]
359
 
        serializer = inventory_delta.InventoryDeltaSerializer(False, True)
 
441
        root_entry = inventory.make_entry('directory', '', None, 'TREE_ROOT')
 
442
        root_entry.revision = 'some-version'
 
443
        delta = [(None, '', 'TREE_ROOT', root_entry)]
 
444
        serializer = inventory_delta.InventoryDeltaSerializer(
 
445
            versioned_root=False, tree_references=True)
360
446
        self.assertRaises(
361
 
            errors.BzrError, serializer.delta_to_lines, 'old-version',
 
447
            InventoryDeltaError, serializer.delta_to_lines, 'old-version',
362
448
            'new-version', delta)
363
449
 
364
450
    def test_to_inventory_root_id_not_versioned(self):
365
 
        delta = [(None, '/', 'an-id', inventory.make_entry(
 
451
        delta = [(None, '', 'an-id', inventory.make_entry(
366
452
            'directory', '', None, 'an-id'))]
367
 
        serializer = inventory_delta.InventoryDeltaSerializer(True, True)
 
453
        serializer = inventory_delta.InventoryDeltaSerializer(
 
454
            versioned_root=True, tree_references=True)
368
455
        self.assertRaises(
369
 
            errors.BzrError, serializer.delta_to_lines, 'old-version',
 
456
            InventoryDeltaError, serializer.delta_to_lines, 'old-version',
370
457
            'new-version', delta)
371
458
 
372
459
    def test_to_inventory_has_tree_not_meant_to(self):
374
461
        tree_ref = make_entry('tree-reference', 'foo', 'changed-in', 'ref-id')
375
462
        tree_ref.reference_revision = 'ref-revision'
376
463
        delta = [
377
 
            (None, '/', 'an-id',
 
464
            (None, '', 'an-id',
378
465
             make_entry('directory', '', 'changed-in', 'an-id')),
379
 
            (None, '/foo', 'ref-id', tree_ref)
 
466
            (None, 'foo', 'ref-id', tree_ref)
380
467
            # a file that followed the root move
381
468
            ]
382
 
        serializer = inventory_delta.InventoryDeltaSerializer(True, True)
383
 
        self.assertRaises(errors.BzrError, serializer.delta_to_lines,
 
469
        serializer = inventory_delta.InventoryDeltaSerializer(
 
470
            versioned_root=True, tree_references=True)
 
471
        self.assertRaises(InventoryDeltaError, serializer.delta_to_lines,
384
472
            'old-version', 'new-version', delta)
385
473
 
386
474
    def test_to_inventory_torture(self):
430
518
                   executable=True, text_size=30, text_sha1='some-sha',
431
519
                   revision='old-rev')),
432
520
            ]
433
 
        serializer = inventory_delta.InventoryDeltaSerializer(True, True)
 
521
        serializer = inventory_delta.InventoryDeltaSerializer(
 
522
            versioned_root=True, tree_references=True)
434
523
        lines = serializer.delta_to_lines(NULL_REVISION, 'something', delta)
435
524
        expected = """format: bzr inventory delta v1 (bzr 1.14)
436
525
parent: null:
483
572
    def test_file_without_size(self):
484
573
        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
485
574
        file_entry.text_sha1 = 'foo'
486
 
        self.assertRaises(errors.BzrError,
 
575
        self.assertRaises(InventoryDeltaError,
487
576
            inventory_delta._file_content, file_entry)
488
577
 
489
578
    def test_file_without_sha1(self):
490
579
        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
491
580
        file_entry.text_size = 10
492
 
        self.assertRaises(errors.BzrError,
 
581
        self.assertRaises(InventoryDeltaError,
493
582
            inventory_delta._file_content, file_entry)
494
583
 
495
584
    def test_link_empty_target(self):
512
601
 
513
602
    def test_link_no_target(self):
514
603
        entry = inventory.make_entry('symlink', 'a link', None)
515
 
        self.assertRaises(errors.BzrError,
 
604
        self.assertRaises(InventoryDeltaError,
516
605
            inventory_delta._link_content, entry)
517
606
 
518
607
    def test_reference_null(self):
529
618
 
530
619
    def test_reference_no_reference(self):
531
620
        entry = inventory.make_entry('tree-reference', 'a tree', None)
532
 
        self.assertRaises(errors.BzrError,
 
621
        self.assertRaises(InventoryDeltaError,
533
622
            inventory_delta._reference_content, entry)