/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-03-05 07:32:38 UTC
  • mto: (7290.1.21 work)
  • mto: This revision was merged to the branch mainline in revision 7311.
  • Revision ID: jelmer@jelmer.uk-20190305073238-zlqn981opwnqsmzi
Add appveyor configuration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_xml.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from io import BytesIO
18
17
 
19
 
from ... import (
 
18
from .. import (
20
19
    errors,
21
20
    fifo_cache,
22
21
    )
23
 
from .. import (
 
22
from ..bzr import (
24
23
    inventory,
25
 
    serializer,
26
24
    xml6,
27
25
    xml7,
28
26
    xml8,
29
27
    )
30
 
from ..inventory import Inventory
 
28
from ..sixish import (
 
29
    BytesIO,
 
30
    text_type,
 
31
    )
 
32
from ..bzr.inventory import Inventory
31
33
from . import TestCase
32
34
import breezy.bzr.xml5
33
35
 
168
170
</revision>
169
171
"""
170
172
 
171
 
_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">
172
 
<message>Include &#181;nicode characters
173
 
</message>
174
 
<parents>
175
 
<revision_ref revision_id="erik@b&#229;gfors-01" />
176
 
<revision_ref revision_id="erik@bagfors-02" />
177
 
</parents>
178
 
<properties><property name="bar" />
179
 
<property name="foo">this has a
180
 
newline in it</property>
181
 
</properties>
182
 
</revision>
183
 
"""
184
 
 
185
 
 
186
 
 
187
173
_inventory_utf8_v5 = b"""<inventory file_id="TRE&#233;_ROOT" format="5"
188
174
                                   revision_id="erik@b&#229;gfors-02">
189
175
<file file_id="b&#229;r-01"
250
236
 
251
237
    def test_unpack_basis_inventory_5(self):
252
238
        """Unpack canned new-style inventory"""
253
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
254
 
            breezy.osutils.split_lines(_basis_inv_v5))
 
239
        inp = BytesIO(_basis_inv_v5)
 
240
        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
255
241
        eq = self.assertEqual
256
242
        eq(len(inv), 4)
257
243
        eq(inv.revision_id,
263
249
        eq(inv.get_entry(ie.parent_id).kind, 'directory')
264
250
 
265
251
    def test_unpack_inventory_5a(self):
266
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
267
 
            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')
268
254
        self.assertEqual(b'test-rev-id', inv.root.revision)
269
255
 
270
256
    def test_unpack_inventory_5a_cache_and_copy(self):
272
258
        # But the returned objects should be copies if return_from_cache is
273
259
        # False
274
260
        entry_cache = fifo_cache.FIFOCache()
275
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
276
 
            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',
277
263
            entry_cache=entry_cache, return_from_cache=False)
278
264
        for entry in inv.iter_just_entries():
279
265
            key = (entry.file_id, entry.revision)
288
274
        # The returned objects should be exact if return_from_cache is
289
275
        # True
290
276
        entry_cache = fifo_cache.FIFOCache()
291
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
292
 
            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',
293
279
            entry_cache=entry_cache, return_from_cache=True)
294
280
        for entry in inv.iter_just_entries():
295
281
            key = (entry.file_id, entry.revision)
300
286
                self.assertIs(entry, entry_cache[key])
301
287
 
302
288
    def test_unpack_inventory_5b(self):
303
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
304
 
            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')
305
291
        self.assertEqual(b'a-rev-id', inv.root.revision)
306
292
 
307
293
    def test_repack_inventory_5(self):
308
 
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
309
 
            breezy.osutils.split_lines(_committed_inv_v5))
 
294
        inp = BytesIO(_committed_inv_v5)
 
295
        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
310
296
        outp = BytesIO()
311
297
        breezy.bzr.xml5.serializer_v5.write_inventory(inv, outp)
312
298
        self.assertEqualDiff(_expected_inv_v5, outp.getvalue())
313
 
        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
314
 
            breezy.osutils.split_lines(outp.getvalue()))
 
299
        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory(
 
300
            BytesIO(outp.getvalue()))
315
301
        self.assertEqual(inv, inv2)
316
302
 
317
303
    def assertRoundTrips(self, xml_string):
334
320
        """Check that repacking a revision yields the same information"""
335
321
        inp = BytesIO(txt)
336
322
        rev = breezy.bzr.xml5.serializer_v5.read_revision(inp)
337
 
        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()
338
326
        rev2 = breezy.bzr.xml5.serializer_v5.read_revision(
339
327
            BytesIO(outfile_contents))
340
328
        self.assertEqual(rev, rev2)
351
339
        # fixed 20051025, revisions should have final newline
352
340
        rev = breezy.bzr.xml5.serializer_v5.read_revision_from_string(
353
341
            _revision_v5)
354
 
        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()
355
345
        self.assertEqual(outfile_contents[-1:], b'\n')
356
346
        self.assertEqualDiff(
357
347
            outfile_contents,
358
 
            b''.join(breezy.bzr.xml5.serializer_v5.write_revision_to_lines(rev)))
 
348
            breezy.bzr.xml5.serializer_v5.write_revision_to_string(rev))
359
349
        self.assertEqualDiff(outfile_contents, _expected_rev_v5)
360
350
 
361
351
    def test_empty_property_value(self):
364
354
        rev = s_v5.read_revision_from_string(_revision_v5)
365
355
        props = {'empty': '', 'one': 'one'}
366
356
        rev.properties = props
367
 
        txt = b''.join(s_v5.write_revision_to_lines(rev))
 
357
        txt = s_v5.write_revision_to_string(rev)
368
358
        new_rev = s_v5.read_revision_from_string(txt)
369
359
        self.assertEqual(props, new_rev.properties)
370
360
 
387
377
        inv = self.get_sample_inventory()
388
378
        inv.add(inventory.TreeReference(b'nested-id', 'nested', b'tree-root-321',
389
379
                                        b'rev_outer', b'rev_inner'))
 
380
        txt = xml7.serializer_v7.write_inventory_to_string(inv)
390
381
        lines = xml7.serializer_v7.write_inventory_to_lines(inv)
391
 
        self.assertEqualDiff(_expected_inv_v7, b''.join(lines))
392
 
        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)
393
385
        self.assertEqual(5, len(inv2))
394
386
        for path, ie in inv.iter_entries():
395
387
            self.assertEqual(ie, inv2.get_entry(ie.file_id))
396
388
 
397
389
    def test_roundtrip_inventory_v6(self):
398
390
        inv = self.get_sample_inventory()
 
391
        txt = xml6.serializer_v6.write_inventory_to_string(inv)
399
392
        lines = xml6.serializer_v6.write_inventory_to_lines(inv)
400
 
        self.assertEqualDiff(_expected_inv_v6, b''.join(lines))
401
 
        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)
402
396
        self.assertEqual(4, len(inv2))
403
397
        for path, ie in inv.iter_entries():
404
398
            self.assertEqual(ie, inv2.get_entry(ie.file_id))
407
401
        """Can't accidentally open a file with wrong serializer"""
408
402
        s_v6 = breezy.bzr.xml6.serializer_v6
409
403
        s_v7 = xml7.serializer_v7
410
 
        self.assertRaises(serializer.UnexpectedInventoryFormat,
411
 
                          s_v7.read_inventory_from_lines,
412
 
                          breezy.osutils.split_lines(_expected_inv_v5))
413
 
        self.assertRaises(serializer.UnexpectedInventoryFormat,
414
 
                          s_v6.read_inventory_from_lines,
415
 
                          breezy.osutils.split_lines(_expected_inv_v7))
 
404
        self.assertRaises(errors.UnexpectedInventoryFormat,
 
405
                          s_v7.read_inventory_from_string, _expected_inv_v5)
 
406
        self.assertRaises(errors.UnexpectedInventoryFormat,
 
407
                          s_v6.read_inventory_from_string, _expected_inv_v7)
416
408
 
417
409
    def test_tree_reference(self):
418
410
        s_v5 = breezy.bzr.xml5.serializer_v5
422
414
        inv.root.revision = b'root-rev'
423
415
        inv.add(inventory.TreeReference(b'nested-id', 'nested', b'tree-root-321',
424
416
                                        b'rev-outer', b'rev-inner'))
425
 
        self.assertRaises(serializer.UnsupportedInventoryKind,
426
 
                          s_v5.write_inventory_to_lines, inv)
427
 
        self.assertRaises(serializer.UnsupportedInventoryKind,
428
 
                          s_v6.write_inventory_to_lines, inv)
429
 
        lines = s_v7.write_inventory_to_chunks(inv)
430
 
        inv2 = s_v7.read_inventory_from_lines(lines)
 
417
        self.assertRaises(errors.UnsupportedInventoryKind,
 
418
                          s_v5.write_inventory_to_string, inv)
 
419
        self.assertRaises(errors.UnsupportedInventoryKind,
 
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)
431
425
        self.assertEqual(b'tree-root-321',
432
426
                         inv2.get_entry(b'nested-id').parent_id)
433
427
        self.assertEqual(b'rev-outer', inv2.get_entry(b'nested-id').revision)
436
430
 
437
431
    def test_roundtrip_inventory_v8(self):
438
432
        inv = self.get_sample_inventory()
439
 
        lines = xml8.serializer_v8.write_inventory_to_lines(inv)
440
 
        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)
441
435
        self.assertEqual(4, len(inv2))
442
436
        for path, ie in inv.iter_entries():
443
437
            self.assertEqual(ie, inv2.get_entry(ie.file_id))
444
438
 
445
439
    def test_inventory_text_v8(self):
446
440
        inv = self.get_sample_inventory()
 
441
        txt = xml8.serializer_v8.write_inventory_to_string(inv)
447
442
        lines = xml8.serializer_v8.write_inventory_to_lines(inv)
448
 
        self.assertEqualDiff(_expected_inv_v8, b''.join(lines))
 
443
        self.assertEqual(breezy.osutils.split_lines(txt), lines)
 
444
        self.assertEqualDiff(_expected_inv_v8, txt)
449
445
 
450
446
    def test_revision_text_v6(self):
451
447
        """Pack revision to XML v6"""
452
448
        rev = breezy.bzr.xml6.serializer_v6.read_revision_from_string(
453
449
            _expected_rev_v5)
454
 
        serialized = breezy.bzr.xml6.serializer_v6.write_revision_to_lines(
 
450
        serialized = breezy.bzr.xml6.serializer_v6.write_revision_to_string(
455
451
            rev)
456
 
        self.assertEqualDiff(b''.join(serialized), _expected_rev_v5)
 
452
        self.assertEqualDiff(serialized, _expected_rev_v5)
457
453
 
458
454
    def test_revision_text_v7(self):
459
455
        """Pack revision to XML v7"""
460
456
        rev = breezy.bzr.xml7.serializer_v7.read_revision_from_string(
461
457
            _expected_rev_v5)
462
 
        serialized = breezy.bzr.xml7.serializer_v7.write_revision_to_lines(
 
458
        serialized = breezy.bzr.xml7.serializer_v7.write_revision_to_string(
463
459
            rev)
464
 
        self.assertEqualDiff(b''.join(serialized), _expected_rev_v5)
 
460
        self.assertEqualDiff(serialized, _expected_rev_v5)
465
461
 
466
462
    def test_revision_text_v8(self):
467
463
        """Pack revision to XML v8"""
468
464
        rev = breezy.bzr.xml8.serializer_v8.read_revision_from_string(
469
465
            _expected_rev_v8)
470
 
        serialized = breezy.bzr.xml8.serializer_v8.write_revision_to_lines(
471
 
            rev)
472
 
        self.assertEqualDiff(b''.join(serialized), _expected_rev_v8)
473
 
 
474
 
    def test_revision_text_v8_complex(self):
475
 
        """Pack revision to XML v8"""
476
 
        rev = breezy.bzr.xml8.serializer_v8.read_revision_from_string(
477
 
            _expected_rev_v8_complex)
478
 
        serialized = breezy.bzr.xml8.serializer_v8.write_revision_to_lines(
479
 
            rev)
480
 
        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)
481
469
 
482
470
    def test_revision_ids_are_utf8(self):
483
471
        """Parsed revision_ids should all be utf-8 strings, not unicode."""
489
477
        for parent_id in rev.parent_ids:
490
478
            self.assertIsInstance(parent_id, bytes)
491
479
        self.assertEqual(u'Include \xb5nicode characters\n', rev.message)
492
 
        self.assertIsInstance(rev.message, str)
 
480
        self.assertIsInstance(rev.message, text_type)
493
481
 
494
482
        # ie.revision should either be None or a utf-8 revision id
495
 
        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)
496
484
        rev_id_1 = u'erik@b\xe5gfors-01'.encode('utf8')
497
485
        rev_id_2 = u'erik@b\xe5gfors-02'.encode('utf8')
498
486
        fid_root = u'TRE\xe9_ROOT'.encode('utf8')
511
499
        for ((exp_path, exp_file_id, exp_parent_id, exp_rev_id),
512
500
             (act_path, act_ie)) in zip(expected, actual):
513
501
            self.assertEqual(exp_path, act_path)
514
 
            self.assertIsInstance(act_path, str)
 
502
            self.assertIsInstance(act_path, text_type)
515
503
            self.assertEqual(exp_file_id, act_ie.file_id)
516
504
            self.assertIsInstance(act_ie.file_id, bytes)
517
505
            self.assertEqual(exp_parent_id, act_ie.parent_id)
526
514
    def test_serialization_error(self):
527
515
        s_v5 = breezy.bzr.xml5.serializer_v5
528
516
        e = self.assertRaises(
529
 
            serializer.UnexpectedInventoryFormat,
530
 
            s_v5.read_inventory_from_lines, [b"<Notquitexml"])
 
517
            errors.UnexpectedInventoryFormat,
 
518
            s_v5.read_inventory_from_string, b"<Notquitexml")
531
519
        self.assertEqual(str(e), "unclosed token: line 1, column 0")
532
520
 
533
521
 
545
533
        # are being used in xml attributes, and by returning it now, we have to
546
534
        # do fewer string operations later.
547
535
        val = breezy.bzr.xml_serializer.encode_and_escape('foo bar')
548
 
        self.assertEqual(b'foo bar', val)
 
536
        self.assertEqual(b'foo bar"', val)
549
537
        # The second time should be cached
550
538
        val2 = breezy.bzr.xml_serializer.encode_and_escape('foo bar')
551
539
        self.assertIs(val2, val)
552
540
 
553
541
    def test_ascii_with_xml(self):
554
 
        self.assertEqual(b'&amp;&apos;&quot;&lt;&gt;',
 
542
        self.assertEqual(b'&amp;&apos;&quot;&lt;&gt;"',
555
543
                         breezy.bzr.xml_serializer.encode_and_escape('&\'"<>'))
556
544
 
557
545
    def test_utf8_with_xml(self):
558
546
        # u'\xb5\xe5&\u062c'
559
547
        utf8_str = b'\xc2\xb5\xc3\xa5&\xd8\xac'
560
 
        self.assertEqual(b'&#181;&#229;&amp;&#1580;',
 
548
        self.assertEqual(b'&#181;&#229;&amp;&#1580;"',
561
549
                         breezy.bzr.xml_serializer.encode_and_escape(utf8_str))
562
550
 
563
551
    def test_unicode(self):
564
552
        uni_str = u'\xb5\xe5&\u062c'
565
 
        self.assertEqual(b'&#181;&#229;&amp;&#1580;',
 
553
        self.assertEqual(b'&#181;&#229;&amp;&#1580;"',
566
554
                         breezy.bzr.xml_serializer.encode_and_escape(uni_str))
567
555
 
568
556