/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_xml.py

Merge test-run support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_xml.py
170
170
</revision>
171
171
"""
172
172
 
173
 
_expected_rev_v8_complex = b"""<revision committer="Erik B&#229;gfors &lt;erik@foo.net&gt;" format="8" inventory_sha1="e79c31c1deb64c163cf660fdedd476dd579ffd41" revision_id="erik@b&#229;gfors-02" timestamp="1125907235.212" timezone="36000">
174
 
<message>Include &#181;nicode characters
175
 
</message>
176
 
<parents>
177
 
<revision_ref revision_id="erik@b&#229;gfors-01" />
178
 
<revision_ref revision_id="erik@bagfors-02" />
179
 
</parents>
180
 
<properties><property name="bar" />
181
 
<property name="foo">this has a
182
 
newline in it</property>
183
 
</properties>
184
 
</revision>
185
 
"""
186
 
 
187
 
 
188
 
 
189
173
_inventory_utf8_v5 = b"""<inventory file_id="TRE&#233;_ROOT" format="5"
190
174
                                   revision_id="erik@b&#229;gfors-02">
191
175
<file file_id="b&#229;r-01"
252
236
 
253
237
    def test_unpack_basis_inventory_5(self):
254
238
        """Unpack canned new-style inventory"""
255
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
256
 
            breezy.osutils.split_lines(_basis_inv_v5))
 
239
        inp = BytesIO(_basis_inv_v5)
 
240
        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
257
241
        eq = self.assertEqual
258
242
        eq(len(inv), 4)
259
 
        eq(inv.revision_id,
260
 
           b'mbp@sourcefrog.net-20050905063503-43948f59fa127d92')
 
243
        eq(inv.revision_id, b'mbp@sourcefrog.net-20050905063503-43948f59fa127d92')
261
244
        ie = inv.get_entry(b'bar-20050824000535-6bc48cfad47ed134')
262
245
        eq(ie.kind, 'file')
263
246
        eq(ie.revision, b'mbp@foo-00')
265
248
        eq(inv.get_entry(ie.parent_id).kind, 'directory')
266
249
 
267
250
    def test_unpack_inventory_5a(self):
268
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
269
 
            breezy.osutils.split_lines(_inventory_v5a), revision_id=b'test-rev-id')
 
251
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
 
252
                _inventory_v5a, revision_id=b'test-rev-id')
270
253
        self.assertEqual(b'test-rev-id', inv.root.revision)
271
254
 
272
255
    def test_unpack_inventory_5a_cache_and_copy(self):
274
257
        # But the returned objects should be copies if return_from_cache is
275
258
        # False
276
259
        entry_cache = fifo_cache.FIFOCache()
277
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
278
 
            breezy.osutils.split_lines(_inventory_v5a), revision_id=b'test-rev-id',
 
260
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
 
261
            _inventory_v5a, revision_id=b'test-rev-id',
279
262
            entry_cache=entry_cache, return_from_cache=False)
280
263
        for entry in inv.iter_just_entries():
281
264
            key = (entry.file_id, entry.revision)
290
273
        # The returned objects should be exact if return_from_cache is
291
274
        # True
292
275
        entry_cache = fifo_cache.FIFOCache()
293
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
294
 
            breezy.osutils.split_lines(_inventory_v5a), revision_id=b'test-rev-id',
 
276
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
 
277
            _inventory_v5a, revision_id=b'test-rev-id',
295
278
            entry_cache=entry_cache, return_from_cache=True)
296
279
        for entry in inv.iter_just_entries():
297
280
            key = (entry.file_id, entry.revision)
302
285
                self.assertIs(entry, entry_cache[key])
303
286
 
304
287
    def test_unpack_inventory_5b(self):
305
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
306
 
            breezy.osutils.split_lines(_inventory_v5b), revision_id=b'test-rev-id')
 
288
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
 
289
                _inventory_v5b, revision_id=b'test-rev-id')
307
290
        self.assertEqual(b'a-rev-id', inv.root.revision)
308
291
 
309
292
    def test_repack_inventory_5(self):
310
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
311
 
            breezy.osutils.split_lines(_committed_inv_v5))
 
293
        inp = BytesIO(_committed_inv_v5)
 
294
        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
312
295
        outp = BytesIO()
313
296
        breezy.bzr.xml5.serializer_v5.write_inventory(inv, outp)
314
297
        self.assertEqualDiff(_expected_inv_v5, outp.getvalue())
315
 
        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
316
 
            breezy.osutils.split_lines(outp.getvalue()))
 
298
        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory(BytesIO(outp.getvalue()))
317
299
        self.assertEqual(inv, inv2)
318
300
 
319
301
    def assertRoundTrips(self, xml_string):
325
307
        lines = breezy.bzr.xml5.serializer_v5.write_inventory_to_lines(inv)
326
308
        outp.seek(0)
327
309
        self.assertEqual(outp.readlines(), lines)
328
 
        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory(
329
 
            BytesIO(outp.getvalue()))
 
310
        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory(BytesIO(outp.getvalue()))
330
311
        self.assertEqual(inv, inv2)
331
312
 
332
313
    def tests_serialize_inventory_v5_with_root(self):
336
317
        """Check that repacking a revision yields the same information"""
337
318
        inp = BytesIO(txt)
338
319
        rev = breezy.bzr.xml5.serializer_v5.read_revision(inp)
339
 
        outfile_contents = breezy.bzr.xml5.serializer_v5.write_revision_to_string(rev)
340
 
        rev2 = breezy.bzr.xml5.serializer_v5.read_revision(
341
 
            BytesIO(outfile_contents))
 
320
        outp = BytesIO()
 
321
        breezy.bzr.xml5.serializer_v5.write_revision(rev, outp)
 
322
        outfile_contents = outp.getvalue()
 
323
        rev2 = breezy.bzr.xml5.serializer_v5.read_revision(BytesIO(outfile_contents))
342
324
        self.assertEqual(rev, rev2)
343
325
 
344
326
    def test_repack_revision_5(self):
351
333
    def test_pack_revision_5(self):
352
334
        """Pack revision to XML v5"""
353
335
        # fixed 20051025, revisions should have final newline
354
 
        rev = breezy.bzr.xml5.serializer_v5.read_revision_from_string(
355
 
            _revision_v5)
356
 
        outfile_contents = breezy.bzr.xml5.serializer_v5.write_revision_to_string(rev)
 
336
        rev = breezy.bzr.xml5.serializer_v5.read_revision_from_string(_revision_v5)
 
337
        outp = BytesIO()
 
338
        breezy.bzr.xml5.serializer_v5.write_revision(rev, outp)
 
339
        outfile_contents = outp.getvalue()
357
340
        self.assertEqual(outfile_contents[-1:], b'\n')
358
 
        self.assertEqualDiff(
359
 
            outfile_contents,
360
 
            b''.join(breezy.bzr.xml5.serializer_v5.write_revision_to_lines(rev)))
 
341
        self.assertEqualDiff(outfile_contents, breezy.bzr.xml5.serializer_v5.write_revision_to_string(rev))
361
342
        self.assertEqualDiff(outfile_contents, _expected_rev_v5)
362
343
 
363
344
    def test_empty_property_value(self):
364
345
        """Create an empty property value check that it serializes correctly"""
365
346
        s_v5 = breezy.bzr.xml5.serializer_v5
366
347
        rev = s_v5.read_revision_from_string(_revision_v5)
367
 
        props = {'empty': '', 'one': 'one'}
 
348
        outp = BytesIO()
 
349
        props = {'empty':'', 'one':'one'}
368
350
        rev.properties = props
369
 
        txt = b''.join(s_v5.write_revision_to_lines(rev))
 
351
        txt = s_v5.write_revision_to_string(rev)
370
352
        new_rev = s_v5.read_revision_from_string(txt)
371
353
        self.assertEqual(props, new_rev.properties)
372
354
 
389
371
        inv = self.get_sample_inventory()
390
372
        inv.add(inventory.TreeReference(b'nested-id', 'nested', b'tree-root-321',
391
373
                                        b'rev_outer', b'rev_inner'))
 
374
        txt = xml7.serializer_v7.write_inventory_to_string(inv)
392
375
        lines = xml7.serializer_v7.write_inventory_to_lines(inv)
393
 
        self.assertEqualDiff(_expected_inv_v7, b''.join(lines))
394
 
        inv2 = xml7.serializer_v7.read_inventory_from_lines(lines)
 
376
        self.assertEqual(breezy.osutils.split_lines(txt), lines)
 
377
        self.assertEqualDiff(_expected_inv_v7, txt)
 
378
        inv2 = xml7.serializer_v7.read_inventory_from_string(txt)
395
379
        self.assertEqual(5, len(inv2))
396
380
        for path, ie in inv.iter_entries():
397
381
            self.assertEqual(ie, inv2.get_entry(ie.file_id))
398
382
 
399
383
    def test_roundtrip_inventory_v6(self):
400
384
        inv = self.get_sample_inventory()
 
385
        txt = xml6.serializer_v6.write_inventory_to_string(inv)
401
386
        lines = xml6.serializer_v6.write_inventory_to_lines(inv)
402
 
        self.assertEqualDiff(_expected_inv_v6, b''.join(lines))
403
 
        inv2 = xml6.serializer_v6.read_inventory_from_lines(lines)
 
387
        self.assertEqual(breezy.osutils.split_lines(txt), lines)
 
388
        self.assertEqualDiff(_expected_inv_v6, txt)
 
389
        inv2 = xml6.serializer_v6.read_inventory_from_string(txt)
404
390
        self.assertEqual(4, len(inv2))
405
391
        for path, ie in inv.iter_entries():
406
392
            self.assertEqual(ie, inv2.get_entry(ie.file_id))
410
396
        s_v6 = breezy.bzr.xml6.serializer_v6
411
397
        s_v7 = xml7.serializer_v7
412
398
        self.assertRaises(errors.UnexpectedInventoryFormat,
413
 
                          s_v7.read_inventory_from_lines,
414
 
                          breezy.osutils.split_lines(_expected_inv_v5))
 
399
                          s_v7.read_inventory_from_string, _expected_inv_v5)
415
400
        self.assertRaises(errors.UnexpectedInventoryFormat,
416
 
                          s_v6.read_inventory_from_lines,
417
 
                          breezy.osutils.split_lines(_expected_inv_v7))
 
401
                          s_v6.read_inventory_from_string, _expected_inv_v7)
418
402
 
419
403
    def test_tree_reference(self):
420
404
        s_v5 = breezy.bzr.xml5.serializer_v5
425
409
        inv.add(inventory.TreeReference(b'nested-id', 'nested', b'tree-root-321',
426
410
                                        b'rev-outer', b'rev-inner'))
427
411
        self.assertRaises(errors.UnsupportedInventoryKind,
428
 
                          s_v5.write_inventory_to_lines, inv)
 
412
                          s_v5.write_inventory_to_string, inv)
429
413
        self.assertRaises(errors.UnsupportedInventoryKind,
430
 
                          s_v6.write_inventory_to_lines, inv)
431
 
        lines = s_v7.write_inventory_to_chunks(inv)
432
 
        inv2 = s_v7.read_inventory_from_lines(lines)
433
 
        self.assertEqual(b'tree-root-321',
434
 
                         inv2.get_entry(b'nested-id').parent_id)
 
414
                          s_v6.write_inventory_to_string, inv)
 
415
        txt = s_v7.write_inventory_to_string(inv)
 
416
        lines = s_v7.write_inventory_to_lines(inv)
 
417
        self.assertEqual(breezy.osutils.split_lines(txt), lines)
 
418
        inv2 = s_v7.read_inventory_from_string(txt)
 
419
        self.assertEqual(b'tree-root-321', inv2.get_entry(b'nested-id').parent_id)
435
420
        self.assertEqual(b'rev-outer', inv2.get_entry(b'nested-id').revision)
436
 
        self.assertEqual(
437
 
            b'rev-inner', inv2.get_entry(b'nested-id').reference_revision)
 
421
        self.assertEqual(b'rev-inner', inv2.get_entry(b'nested-id').reference_revision)
438
422
 
439
423
    def test_roundtrip_inventory_v8(self):
440
424
        inv = self.get_sample_inventory()
441
 
        lines = xml8.serializer_v8.write_inventory_to_lines(inv)
442
 
        inv2 = xml8.serializer_v8.read_inventory_from_lines(lines)
 
425
        txt = xml8.serializer_v8.write_inventory_to_string(inv)
 
426
        inv2 = xml8.serializer_v8.read_inventory_from_string(txt)
443
427
        self.assertEqual(4, len(inv2))
444
428
        for path, ie in inv.iter_entries():
445
429
            self.assertEqual(ie, inv2.get_entry(ie.file_id))
446
430
 
447
431
    def test_inventory_text_v8(self):
448
432
        inv = self.get_sample_inventory()
 
433
        txt = xml8.serializer_v8.write_inventory_to_string(inv)
449
434
        lines = xml8.serializer_v8.write_inventory_to_lines(inv)
450
 
        self.assertEqualDiff(_expected_inv_v8, b''.join(lines))
 
435
        self.assertEqual(breezy.osutils.split_lines(txt), lines)
 
436
        self.assertEqualDiff(_expected_inv_v8, txt)
451
437
 
452
438
    def test_revision_text_v6(self):
453
439
        """Pack revision to XML v6"""
454
440
        rev = breezy.bzr.xml6.serializer_v6.read_revision_from_string(
455
441
            _expected_rev_v5)
456
 
        serialized = breezy.bzr.xml6.serializer_v6.write_revision_to_lines(
457
 
            rev)
458
 
        self.assertEqualDiff(b''.join(serialized), _expected_rev_v5)
 
442
        serialized = breezy.bzr.xml6.serializer_v6.write_revision_to_string(rev)
 
443
        self.assertEqualDiff(serialized, _expected_rev_v5)
459
444
 
460
445
    def test_revision_text_v7(self):
461
446
        """Pack revision to XML v7"""
462
447
        rev = breezy.bzr.xml7.serializer_v7.read_revision_from_string(
463
448
            _expected_rev_v5)
464
 
        serialized = breezy.bzr.xml7.serializer_v7.write_revision_to_lines(
465
 
            rev)
466
 
        self.assertEqualDiff(b''.join(serialized), _expected_rev_v5)
 
449
        serialized = breezy.bzr.xml7.serializer_v7.write_revision_to_string(rev)
 
450
        self.assertEqualDiff(serialized, _expected_rev_v5)
467
451
 
468
452
    def test_revision_text_v8(self):
469
453
        """Pack revision to XML v8"""
470
454
        rev = breezy.bzr.xml8.serializer_v8.read_revision_from_string(
471
455
            _expected_rev_v8)
472
 
        serialized = breezy.bzr.xml8.serializer_v8.write_revision_to_lines(
473
 
            rev)
474
 
        self.assertEqualDiff(b''.join(serialized), _expected_rev_v8)
475
 
 
476
 
    def test_revision_text_v8_complex(self):
477
 
        """Pack revision to XML v8"""
478
 
        rev = breezy.bzr.xml8.serializer_v8.read_revision_from_string(
479
 
            _expected_rev_v8_complex)
480
 
        serialized = breezy.bzr.xml8.serializer_v8.write_revision_to_lines(
481
 
            rev)
482
 
        self.assertEqualDiff(b''.join(serialized), _expected_rev_v8_complex)
 
456
        serialized = breezy.bzr.xml8.serializer_v8.write_revision_to_string(rev)
 
457
        self.assertEqualDiff(serialized, _expected_rev_v8)
483
458
 
484
459
    def test_revision_ids_are_utf8(self):
485
460
        """Parsed revision_ids should all be utf-8 strings, not unicode."""
494
469
        self.assertIsInstance(rev.message, text_type)
495
470
 
496
471
        # ie.revision should either be None or a utf-8 revision id
497
 
        inv = s_v5.read_inventory_from_lines(breezy.osutils.split_lines(_inventory_utf8_v5))
 
472
        inv = s_v5.read_inventory_from_string(_inventory_utf8_v5)
498
473
        rev_id_1 = u'erik@b\xe5gfors-01'.encode('utf8')
499
474
        rev_id_2 = u'erik@b\xe5gfors-02'.encode('utf8')
500
475
        fid_root = u'TRE\xe9_ROOT'.encode('utf8')
505
480
                    (u'b\xe5r', fid_bar1, fid_root, rev_id_1),
506
481
                    (u's\xb5bdir', fid_sub, fid_root, rev_id_1),
507
482
                    (u's\xb5bdir/b\xe5r', fid_bar2, fid_sub, rev_id_2),
508
 
                    ]
 
483
                   ]
509
484
        self.assertEqual(rev_id_2, inv.revision_id)
510
485
        self.assertIsInstance(inv.revision_id, bytes)
511
486
 
525
500
 
526
501
        self.assertEqual(len(expected), len(actual))
527
502
 
528
 
    def test_serialization_error(self):
529
 
        s_v5 = breezy.bzr.xml5.serializer_v5
530
 
        e = self.assertRaises(
531
 
            errors.UnexpectedInventoryFormat,
532
 
            s_v5.read_inventory_from_lines, [b"<Notquitexml"])
533
 
        self.assertEqual(str(e), "unclosed token: line 1, column 0")
534
 
 
535
503
 
536
504
class TestEncodeAndEscape(TestCase):
537
505
    """Whitebox testing of the _encode_and_escape function."""
547
515
        # are being used in xml attributes, and by returning it now, we have to
548
516
        # do fewer string operations later.
549
517
        val = breezy.bzr.xml_serializer.encode_and_escape('foo bar')
550
 
        self.assertEqual(b'foo bar', val)
 
518
        self.assertEqual(b'foo bar"', val)
551
519
        # The second time should be cached
552
520
        val2 = breezy.bzr.xml_serializer.encode_and_escape('foo bar')
553
521
        self.assertIs(val2, val)
554
522
 
555
523
    def test_ascii_with_xml(self):
556
 
        self.assertEqual(b'&amp;&apos;&quot;&lt;&gt;',
 
524
        self.assertEqual(b'&amp;&apos;&quot;&lt;&gt;"',
557
525
                         breezy.bzr.xml_serializer.encode_and_escape('&\'"<>'))
558
526
 
559
527
    def test_utf8_with_xml(self):
560
528
        # u'\xb5\xe5&\u062c'
561
529
        utf8_str = b'\xc2\xb5\xc3\xa5&\xd8\xac'
562
 
        self.assertEqual(b'&#181;&#229;&amp;&#1580;',
 
530
        self.assertEqual(b'&#181;&#229;&amp;&#1580;"',
563
531
                         breezy.bzr.xml_serializer.encode_and_escape(utf8_str))
564
532
 
565
533
    def test_unicode(self):
566
534
        uni_str = u'\xb5\xe5&\u062c'
567
 
        self.assertEqual(b'&#181;&#229;&amp;&#1580;',
 
535
        self.assertEqual(b'&#181;&#229;&amp;&#1580;"',
568
536
                         breezy.bzr.xml_serializer.encode_and_escape(uni_str))
569
537
 
570
538