/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

  • Committer: Jelmer Vernooij
  • Date: 2019-06-03 23:48:08 UTC
  • mfrom: (7316 work)
  • mto: This revision was merged to the branch mainline in revision 7328.
  • Revision ID: jelmer@jelmer.uk-20190603234808-15yk5c7054tj8e2b
Merge trunk.

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
243
        eq(inv.revision_id,
265
249
        eq(inv.get_entry(ie.parent_id).kind, 'directory')
266
250
 
267
251
    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')
 
252
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
 
253
            _inventory_v5a, revision_id=b'test-rev-id')
270
254
        self.assertEqual(b'test-rev-id', inv.root.revision)
271
255
 
272
256
    def test_unpack_inventory_5a_cache_and_copy(self):
274
258
        # But the returned objects should be copies if return_from_cache is
275
259
        # False
276
260
        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',
 
261
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
 
262
            _inventory_v5a, revision_id=b'test-rev-id',
279
263
            entry_cache=entry_cache, return_from_cache=False)
280
264
        for entry in inv.iter_just_entries():
281
265
            key = (entry.file_id, entry.revision)
290
274
        # The returned objects should be exact if return_from_cache is
291
275
        # True
292
276
        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',
 
277
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
 
278
            _inventory_v5a, revision_id=b'test-rev-id',
295
279
            entry_cache=entry_cache, return_from_cache=True)
296
280
        for entry in inv.iter_just_entries():
297
281
            key = (entry.file_id, entry.revision)
302
286
                self.assertIs(entry, entry_cache[key])
303
287
 
304
288
    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')
 
289
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
 
290
            _inventory_v5b, revision_id=b'test-rev-id')
307
291
        self.assertEqual(b'a-rev-id', inv.root.revision)
308
292
 
309
293
    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))
 
294
        inp = BytesIO(_committed_inv_v5)
 
295
        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
312
296
        outp = BytesIO()
313
297
        breezy.bzr.xml5.serializer_v5.write_inventory(inv, outp)
314
298
        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()))
 
299
        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory(
 
300
            BytesIO(outp.getvalue()))
317
301
        self.assertEqual(inv, inv2)
318
302
 
319
303
    def assertRoundTrips(self, xml_string):
336
320
        """Check that repacking a revision yields the same information"""
337
321
        inp = BytesIO(txt)
338
322
        rev = breezy.bzr.xml5.serializer_v5.read_revision(inp)
339
 
        outfile_contents = breezy.bzr.xml5.serializer_v5.write_revision_to_string(rev)
 
323
        outp = BytesIO()
 
324
        breezy.bzr.xml5.serializer_v5.write_revision(rev, outp)
 
325
        outfile_contents = outp.getvalue()
340
326
        rev2 = breezy.bzr.xml5.serializer_v5.read_revision(
341
327
            BytesIO(outfile_contents))
342
328
        self.assertEqual(rev, rev2)
353
339
        # fixed 20051025, revisions should have final newline
354
340
        rev = breezy.bzr.xml5.serializer_v5.read_revision_from_string(
355
341
            _revision_v5)
356
 
        outfile_contents = breezy.bzr.xml5.serializer_v5.write_revision_to_string(rev)
 
342
        outp = BytesIO()
 
343
        breezy.bzr.xml5.serializer_v5.write_revision(rev, outp)
 
344
        outfile_contents = outp.getvalue()
357
345
        self.assertEqual(outfile_contents[-1:], b'\n')
358
346
        self.assertEqualDiff(
359
347
            outfile_contents,
360
 
            b''.join(breezy.bzr.xml5.serializer_v5.write_revision_to_lines(rev)))
 
348
            breezy.bzr.xml5.serializer_v5.write_revision_to_string(rev))
361
349
        self.assertEqualDiff(outfile_contents, _expected_rev_v5)
362
350
 
363
351
    def test_empty_property_value(self):
366
354
        rev = s_v5.read_revision_from_string(_revision_v5)
367
355
        props = {'empty': '', 'one': 'one'}
368
356
        rev.properties = props
369
 
        txt = b''.join(s_v5.write_revision_to_lines(rev))
 
357
        txt = s_v5.write_revision_to_string(rev)
370
358
        new_rev = s_v5.read_revision_from_string(txt)
371
359
        self.assertEqual(props, new_rev.properties)
372
360
 
389
377
        inv = self.get_sample_inventory()
390
378
        inv.add(inventory.TreeReference(b'nested-id', 'nested', b'tree-root-321',
391
379
                                        b'rev_outer', b'rev_inner'))
 
380
        txt = xml7.serializer_v7.write_inventory_to_string(inv)
392
381
        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)
 
382
        self.assertEqual(breezy.osutils.split_lines(txt), lines)
 
383
        self.assertEqualDiff(_expected_inv_v7, txt)
 
384
        inv2 = xml7.serializer_v7.read_inventory_from_string(txt)
395
385
        self.assertEqual(5, len(inv2))
396
386
        for path, ie in inv.iter_entries():
397
387
            self.assertEqual(ie, inv2.get_entry(ie.file_id))
398
388
 
399
389
    def test_roundtrip_inventory_v6(self):
400
390
        inv = self.get_sample_inventory()
 
391
        txt = xml6.serializer_v6.write_inventory_to_string(inv)
401
392
        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)
 
393
        self.assertEqual(breezy.osutils.split_lines(txt), lines)
 
394
        self.assertEqualDiff(_expected_inv_v6, txt)
 
395
        inv2 = xml6.serializer_v6.read_inventory_from_string(txt)
404
396
        self.assertEqual(4, len(inv2))
405
397
        for path, ie in inv.iter_entries():
406
398
            self.assertEqual(ie, inv2.get_entry(ie.file_id))
410
402
        s_v6 = breezy.bzr.xml6.serializer_v6
411
403
        s_v7 = xml7.serializer_v7
412
404
        self.assertRaises(errors.UnexpectedInventoryFormat,
413
 
                          s_v7.read_inventory_from_lines,
414
 
                          breezy.osutils.split_lines(_expected_inv_v5))
 
405
                          s_v7.read_inventory_from_string, _expected_inv_v5)
415
406
        self.assertRaises(errors.UnexpectedInventoryFormat,
416
 
                          s_v6.read_inventory_from_lines,
417
 
                          breezy.osutils.split_lines(_expected_inv_v7))
 
407
                          s_v6.read_inventory_from_string, _expected_inv_v7)
418
408
 
419
409
    def test_tree_reference(self):
420
410
        s_v5 = breezy.bzr.xml5.serializer_v5
425
415
        inv.add(inventory.TreeReference(b'nested-id', 'nested', b'tree-root-321',
426
416
                                        b'rev-outer', b'rev-inner'))
427
417
        self.assertRaises(errors.UnsupportedInventoryKind,
428
 
                          s_v5.write_inventory_to_lines, inv)
 
418
                          s_v5.write_inventory_to_string, inv)
429
419
        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)
 
420
                          s_v6.write_inventory_to_string, inv)
 
421
        txt = s_v7.write_inventory_to_string(inv)
 
422
        lines = s_v7.write_inventory_to_lines(inv)
 
423
        self.assertEqual(breezy.osutils.split_lines(txt), lines)
 
424
        inv2 = s_v7.read_inventory_from_string(txt)
433
425
        self.assertEqual(b'tree-root-321',
434
426
                         inv2.get_entry(b'nested-id').parent_id)
435
427
        self.assertEqual(b'rev-outer', inv2.get_entry(b'nested-id').revision)
438
430
 
439
431
    def test_roundtrip_inventory_v8(self):
440
432
        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)
 
433
        txt = xml8.serializer_v8.write_inventory_to_string(inv)
 
434
        inv2 = xml8.serializer_v8.read_inventory_from_string(txt)
443
435
        self.assertEqual(4, len(inv2))
444
436
        for path, ie in inv.iter_entries():
445
437
            self.assertEqual(ie, inv2.get_entry(ie.file_id))
446
438
 
447
439
    def test_inventory_text_v8(self):
448
440
        inv = self.get_sample_inventory()
 
441
        txt = xml8.serializer_v8.write_inventory_to_string(inv)
449
442
        lines = xml8.serializer_v8.write_inventory_to_lines(inv)
450
 
        self.assertEqualDiff(_expected_inv_v8, b''.join(lines))
 
443
        self.assertEqual(breezy.osutils.split_lines(txt), lines)
 
444
        self.assertEqualDiff(_expected_inv_v8, txt)
451
445
 
452
446
    def test_revision_text_v6(self):
453
447
        """Pack revision to XML v6"""
454
448
        rev = breezy.bzr.xml6.serializer_v6.read_revision_from_string(
455
449
            _expected_rev_v5)
456
 
        serialized = breezy.bzr.xml6.serializer_v6.write_revision_to_lines(
 
450
        serialized = breezy.bzr.xml6.serializer_v6.write_revision_to_string(
457
451
            rev)
458
 
        self.assertEqualDiff(b''.join(serialized), _expected_rev_v5)
 
452
        self.assertEqualDiff(serialized, _expected_rev_v5)
459
453
 
460
454
    def test_revision_text_v7(self):
461
455
        """Pack revision to XML v7"""
462
456
        rev = breezy.bzr.xml7.serializer_v7.read_revision_from_string(
463
457
            _expected_rev_v5)
464
 
        serialized = breezy.bzr.xml7.serializer_v7.write_revision_to_lines(
 
458
        serialized = breezy.bzr.xml7.serializer_v7.write_revision_to_string(
465
459
            rev)
466
 
        self.assertEqualDiff(b''.join(serialized), _expected_rev_v5)
 
460
        self.assertEqualDiff(serialized, _expected_rev_v5)
467
461
 
468
462
    def test_revision_text_v8(self):
469
463
        """Pack revision to XML v8"""
470
464
        rev = breezy.bzr.xml8.serializer_v8.read_revision_from_string(
471
465
            _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)
 
466
        serialized = breezy.bzr.xml8.serializer_v8.write_revision_to_string(
 
467
            rev)
 
468
        self.assertEqualDiff(serialized, _expected_rev_v8)
483
469
 
484
470
    def test_revision_ids_are_utf8(self):
485
471
        """Parsed revision_ids should all be utf-8 strings, not unicode."""
494
480
        self.assertIsInstance(rev.message, text_type)
495
481
 
496
482
        # 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))
 
483
        inv = s_v5.read_inventory_from_string(_inventory_utf8_v5)
498
484
        rev_id_1 = u'erik@b\xe5gfors-01'.encode('utf8')
499
485
        rev_id_2 = u'erik@b\xe5gfors-02'.encode('utf8')
500
486
        fid_root = u'TRE\xe9_ROOT'.encode('utf8')
529
515
        s_v5 = breezy.bzr.xml5.serializer_v5
530
516
        e = self.assertRaises(
531
517
            errors.UnexpectedInventoryFormat,
532
 
            s_v5.read_inventory_from_lines, [b"<Notquitexml"])
 
518
            s_v5.read_inventory_from_string, b"<Notquitexml")
533
519
        self.assertEqual(str(e), "unclosed token: line 1, column 0")
534
520
 
535
521
 
547
533
        # are being used in xml attributes, and by returning it now, we have to
548
534
        # do fewer string operations later.
549
535
        val = breezy.bzr.xml_serializer.encode_and_escape('foo bar')
550
 
        self.assertEqual(b'foo bar', val)
 
536
        self.assertEqual(b'foo bar"', val)
551
537
        # The second time should be cached
552
538
        val2 = breezy.bzr.xml_serializer.encode_and_escape('foo bar')
553
539
        self.assertIs(val2, val)
554
540
 
555
541
    def test_ascii_with_xml(self):
556
 
        self.assertEqual(b'&amp;&apos;&quot;&lt;&gt;',
 
542
        self.assertEqual(b'&amp;&apos;&quot;&lt;&gt;"',
557
543
                         breezy.bzr.xml_serializer.encode_and_escape('&\'"<>'))
558
544
 
559
545
    def test_utf8_with_xml(self):
560
546
        # u'\xb5\xe5&\u062c'
561
547
        utf8_str = b'\xc2\xb5\xc3\xa5&\xd8\xac'
562
 
        self.assertEqual(b'&#181;&#229;&amp;&#1580;',
 
548
        self.assertEqual(b'&#181;&#229;&amp;&#1580;"',
563
549
                         breezy.bzr.xml_serializer.encode_and_escape(utf8_str))
564
550
 
565
551
    def test_unicode(self):
566
552
        uni_str = u'\xb5\xe5&\u062c'
567
 
        self.assertEqual(b'&#181;&#229;&amp;&#1580;',
 
553
        self.assertEqual(b'&#181;&#229;&amp;&#1580;"',
568
554
                         breezy.bzr.xml_serializer.encode_and_escape(uni_str))
569
555
 
570
556