/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: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_xml.py
18
18
from .. import (
19
19
    errors,
20
20
    fifo_cache,
 
21
    )
 
22
from ..bzr import (
21
23
    inventory,
22
24
    xml6,
23
25
    xml7,
26
28
from ..sixish import (
27
29
    BytesIO,
28
30
    )
29
 
from ..inventory import Inventory
 
31
from ..bzr.inventory import Inventory
30
32
from . import TestCase
31
 
import breezy.xml5
 
33
import breezy.bzr.xml5
32
34
 
33
35
_revision_v5 = """<revision committer="Martin Pool &lt;mbp@sourcefrog.net&gt;"
34
36
    inventory_sha1="e79c31c1deb64c163cf660fdedd476dd579ffd41"
199
201
    def test_unpack_revision_5(self):
200
202
        """Test unpacking a canned revision v5"""
201
203
        inp = BytesIO(_revision_v5)
202
 
        rev = breezy.xml5.serializer_v5.read_revision(inp)
 
204
        rev = breezy.bzr.xml5.serializer_v5.read_revision(inp)
203
205
        eq = self.assertEqual
204
206
        eq(rev.committer,
205
207
           "Martin Pool <mbp@sourcefrog.net>")
210
212
 
211
213
    def test_unpack_revision_5_utc(self):
212
214
        inp = BytesIO(_revision_v5_utc)
213
 
        rev = breezy.xml5.serializer_v5.read_revision(inp)
 
215
        rev = breezy.bzr.xml5.serializer_v5.read_revision(inp)
214
216
        eq = self.assertEqual
215
217
        eq(rev.committer,
216
218
           "Martin Pool <mbp@sourcefrog.net>")
222
224
    def test_unpack_inventory_5(self):
223
225
        """Unpack canned new-style inventory"""
224
226
        inp = BytesIO(_committed_inv_v5)
225
 
        inv = breezy.xml5.serializer_v5.read_inventory(inp)
 
227
        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
226
228
        eq = self.assertEqual
227
229
        eq(len(inv), 4)
228
230
        ie = inv['bar-20050824000535-6bc48cfad47ed134']
234
236
    def test_unpack_basis_inventory_5(self):
235
237
        """Unpack canned new-style inventory"""
236
238
        inp = BytesIO(_basis_inv_v5)
237
 
        inv = breezy.xml5.serializer_v5.read_inventory(inp)
 
239
        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
238
240
        eq = self.assertEqual
239
241
        eq(len(inv), 4)
240
242
        eq(inv.revision_id, 'mbp@sourcefrog.net-20050905063503-43948f59fa127d92')
245
247
        eq(inv[ie.parent_id].kind, 'directory')
246
248
 
247
249
    def test_unpack_inventory_5a(self):
248
 
        inv = breezy.xml5.serializer_v5.read_inventory_from_string(
 
250
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
249
251
                _inventory_v5a, revision_id='test-rev-id')
250
252
        self.assertEqual('test-rev-id', inv.root.revision)
251
253
 
254
256
        # But the returned objects should be copies if return_from_cache is
255
257
        # False
256
258
        entry_cache = fifo_cache.FIFOCache()
257
 
        inv = breezy.xml5.serializer_v5.read_inventory_from_string(
 
259
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
258
260
            _inventory_v5a, revision_id='test-rev-id',
259
261
            entry_cache=entry_cache, return_from_cache=False)
260
262
        for entry in inv.iter_just_entries():
270
272
        # The returned objects should be exact if return_from_cache is
271
273
        # True
272
274
        entry_cache = fifo_cache.FIFOCache()
273
 
        inv = breezy.xml5.serializer_v5.read_inventory_from_string(
 
275
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
274
276
            _inventory_v5a, revision_id='test-rev-id',
275
277
            entry_cache=entry_cache, return_from_cache=True)
276
278
        for entry in inv.iter_just_entries():
282
284
                self.assertIs(entry, entry_cache[key])
283
285
 
284
286
    def test_unpack_inventory_5b(self):
285
 
        inv = breezy.xml5.serializer_v5.read_inventory_from_string(
 
287
        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
286
288
                _inventory_v5b, revision_id='test-rev-id')
287
289
        self.assertEqual('a-rev-id', inv.root.revision)
288
290
 
289
291
    def test_repack_inventory_5(self):
290
292
        inp = BytesIO(_committed_inv_v5)
291
 
        inv = breezy.xml5.serializer_v5.read_inventory(inp)
 
293
        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
292
294
        outp = BytesIO()
293
 
        breezy.xml5.serializer_v5.write_inventory(inv, outp)
 
295
        breezy.bzr.xml5.serializer_v5.write_inventory(inv, outp)
294
296
        self.assertEqualDiff(_expected_inv_v5, outp.getvalue())
295
 
        inv2 = breezy.xml5.serializer_v5.read_inventory(BytesIO(outp.getvalue()))
 
297
        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory(BytesIO(outp.getvalue()))
296
298
        self.assertEqual(inv, inv2)
297
299
 
298
300
    def assertRoundTrips(self, xml_string):
299
301
        inp = BytesIO(xml_string)
300
 
        inv = breezy.xml5.serializer_v5.read_inventory(inp)
 
302
        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
301
303
        outp = BytesIO()
302
 
        breezy.xml5.serializer_v5.write_inventory(inv, outp)
 
304
        breezy.bzr.xml5.serializer_v5.write_inventory(inv, outp)
303
305
        self.assertEqualDiff(xml_string, outp.getvalue())
304
 
        lines = breezy.xml5.serializer_v5.write_inventory_to_lines(inv)
 
306
        lines = breezy.bzr.xml5.serializer_v5.write_inventory_to_lines(inv)
305
307
        outp.seek(0)
306
308
        self.assertEqual(outp.readlines(), lines)
307
 
        inv2 = breezy.xml5.serializer_v5.read_inventory(BytesIO(outp.getvalue()))
 
309
        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory(BytesIO(outp.getvalue()))
308
310
        self.assertEqual(inv, inv2)
309
311
 
310
312
    def tests_serialize_inventory_v5_with_root(self):
313
315
    def check_repack_revision(self, txt):
314
316
        """Check that repacking a revision yields the same information"""
315
317
        inp = BytesIO(txt)
316
 
        rev = breezy.xml5.serializer_v5.read_revision(inp)
 
318
        rev = breezy.bzr.xml5.serializer_v5.read_revision(inp)
317
319
        outp = BytesIO()
318
 
        breezy.xml5.serializer_v5.write_revision(rev, outp)
 
320
        breezy.bzr.xml5.serializer_v5.write_revision(rev, outp)
319
321
        outfile_contents = outp.getvalue()
320
 
        rev2 = breezy.xml5.serializer_v5.read_revision(BytesIO(outfile_contents))
 
322
        rev2 = breezy.bzr.xml5.serializer_v5.read_revision(BytesIO(outfile_contents))
321
323
        self.assertEqual(rev, rev2)
322
324
 
323
325
    def test_repack_revision_5(self):
330
332
    def test_pack_revision_5(self):
331
333
        """Pack revision to XML v5"""
332
334
        # fixed 20051025, revisions should have final newline
333
 
        rev = breezy.xml5.serializer_v5.read_revision_from_string(_revision_v5)
 
335
        rev = breezy.bzr.xml5.serializer_v5.read_revision_from_string(_revision_v5)
334
336
        outp = BytesIO()
335
 
        breezy.xml5.serializer_v5.write_revision(rev, outp)
 
337
        breezy.bzr.xml5.serializer_v5.write_revision(rev, outp)
336
338
        outfile_contents = outp.getvalue()
337
339
        self.assertEqual(outfile_contents[-1], '\n')
338
 
        self.assertEqualDiff(outfile_contents, breezy.xml5.serializer_v5.write_revision_to_string(rev))
 
340
        self.assertEqualDiff(outfile_contents, breezy.bzr.xml5.serializer_v5.write_revision_to_string(rev))
339
341
        self.assertEqualDiff(outfile_contents, _expected_rev_v5)
340
342
 
341
343
    def test_empty_property_value(self):
342
344
        """Create an empty property value check that it serializes correctly"""
343
 
        s_v5 = breezy.xml5.serializer_v5
 
345
        s_v5 = breezy.bzr.xml5.serializer_v5
344
346
        rev = s_v5.read_revision_from_string(_revision_v5)
345
347
        outp = BytesIO()
346
348
        props = {'empty':'', 'one':'one'}
390
392
 
391
393
    def test_wrong_format_v7(self):
392
394
        """Can't accidentally open a file with wrong serializer"""
393
 
        s_v6 = breezy.xml6.serializer_v6
 
395
        s_v6 = breezy.bzr.xml6.serializer_v6
394
396
        s_v7 = xml7.serializer_v7
395
397
        self.assertRaises(errors.UnexpectedInventoryFormat,
396
398
                          s_v7.read_inventory_from_string, _expected_inv_v5)
398
400
                          s_v6.read_inventory_from_string, _expected_inv_v7)
399
401
 
400
402
    def test_tree_reference(self):
401
 
        s_v5 = breezy.xml5.serializer_v5
402
 
        s_v6 = breezy.xml6.serializer_v6
 
403
        s_v5 = breezy.bzr.xml5.serializer_v5
 
404
        s_v6 = breezy.bzr.xml6.serializer_v6
403
405
        s_v7 = xml7.serializer_v7
404
406
        inv = Inventory('tree-root-321', revision_id='rev-outer')
405
407
        inv.root.revision = 'root-rev'
434
436
 
435
437
    def test_revision_text_v6(self):
436
438
        """Pack revision to XML v6"""
437
 
        rev = breezy.xml6.serializer_v6.read_revision_from_string(
 
439
        rev = breezy.bzr.xml6.serializer_v6.read_revision_from_string(
438
440
            _expected_rev_v5)
439
 
        serialized = breezy.xml6.serializer_v6.write_revision_to_string(rev)
 
441
        serialized = breezy.bzr.xml6.serializer_v6.write_revision_to_string(rev)
440
442
        self.assertEqualDiff(serialized, _expected_rev_v5)
441
443
 
442
444
    def test_revision_text_v7(self):
443
445
        """Pack revision to XML v7"""
444
 
        rev = breezy.xml7.serializer_v7.read_revision_from_string(
 
446
        rev = breezy.bzr.xml7.serializer_v7.read_revision_from_string(
445
447
            _expected_rev_v5)
446
 
        serialized = breezy.xml7.serializer_v7.write_revision_to_string(rev)
 
448
        serialized = breezy.bzr.xml7.serializer_v7.write_revision_to_string(rev)
447
449
        self.assertEqualDiff(serialized, _expected_rev_v5)
448
450
 
449
451
    def test_revision_text_v8(self):
450
452
        """Pack revision to XML v8"""
451
 
        rev = breezy.xml8.serializer_v8.read_revision_from_string(
 
453
        rev = breezy.bzr.xml8.serializer_v8.read_revision_from_string(
452
454
            _expected_rev_v8)
453
 
        serialized = breezy.xml8.serializer_v8.write_revision_to_string(rev)
 
455
        serialized = breezy.bzr.xml8.serializer_v8.write_revision_to_string(rev)
454
456
        self.assertEqualDiff(serialized, _expected_rev_v8)
455
457
 
456
458
    def test_revision_ids_are_utf8(self):
457
459
        """Parsed revision_ids should all be utf-8 strings, not unicode."""
458
 
        s_v5 = breezy.xml5.serializer_v5
 
460
        s_v5 = breezy.bzr.xml5.serializer_v5
459
461
        rev = s_v5.read_revision_from_string(_revision_utf8_v5)
460
462
        self.assertEqual('erik@b\xc3\xa5gfors-02', rev.revision_id)
461
463
        self.assertIsInstance(rev.revision_id, str)
504
506
    def setUp(self):
505
507
        super(TestEncodeAndEscape, self).setUp()
506
508
        # Keep the cache clear before and after the test
507
 
        breezy.xml_serializer._clear_cache()
508
 
        self.addCleanup(breezy.xml_serializer._clear_cache)
 
509
        breezy.bzr.xml_serializer._clear_cache()
 
510
        self.addCleanup(breezy.bzr.xml_serializer._clear_cache)
509
511
 
510
512
    def test_simple_ascii(self):
511
513
        # _encode_and_escape always appends a final ", because these parameters
512
514
        # are being used in xml attributes, and by returning it now, we have to
513
515
        # do fewer string operations later.
514
 
        val = breezy.xml_serializer.encode_and_escape('foo bar')
 
516
        val = breezy.bzr.xml_serializer.encode_and_escape('foo bar')
515
517
        self.assertEqual('foo bar"', val)
516
518
        # The second time should be cached
517
 
        val2 = breezy.xml_serializer.encode_and_escape('foo bar')
 
519
        val2 = breezy.bzr.xml_serializer.encode_and_escape('foo bar')
518
520
        self.assertIs(val2, val)
519
521
 
520
522
    def test_ascii_with_xml(self):
521
523
        self.assertEqual('&amp;&apos;&quot;&lt;&gt;"',
522
 
                         breezy.xml_serializer.encode_and_escape('&\'"<>'))
 
524
                         breezy.bzr.xml_serializer.encode_and_escape('&\'"<>'))
523
525
 
524
526
    def test_utf8_with_xml(self):
525
527
        # u'\xb5\xe5&\u062c'
526
528
        utf8_str = '\xc2\xb5\xc3\xa5&\xd8\xac'
527
529
        self.assertEqual('&#181;&#229;&amp;&#1580;"',
528
 
                         breezy.xml_serializer.encode_and_escape(utf8_str))
 
530
                         breezy.bzr.xml_serializer.encode_and_escape(utf8_str))
529
531
 
530
532
    def test_unicode(self):
531
533
        uni_str = u'\xb5\xe5&\u062c'
532
534
        self.assertEqual('&#181;&#229;&amp;&#1580;"',
533
 
                         breezy.xml_serializer.encode_and_escape(uni_str))
 
535
                         breezy.bzr.xml_serializer.encode_and_escape(uni_str))
534
536
 
535
537
 
536
538
class TestMisc(TestCase):
537
539
 
538
540
    def test_unescape_xml(self):
539
541
        """We get some kind of error when malformed entities are passed"""
540
 
        self.assertRaises(KeyError, breezy.xml8._unescape_xml, 'foo&bar;')
 
542
        self.assertRaises(KeyError, breezy.bzr.xml8._unescape_xml, 'foo&bar;')