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

  • Committer: Martin Pool
  • Date: 2007-10-03 08:06:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2901.
  • Revision ID: mbp@sourcefrog.net-20071003080644-oivy0gkg98sex0ed
Avoid internal error tracebacks on failure to lock on readonly transport (#129701).

Add new LockFailed, which doesn't imply that we failed to get it because of
contention.  Raise this if we fail to create the pending or lock directories
because of Transport errors.

UnlockableTransport is not an internal error.

ReadOnlyLockError has a message which didn't match its name or usage; it's now
deprecated and callers are updated to use LockFailed which is more appropriate.

Add zero_ninetytwo deprecation symbol.

Unify assertMatchesRe with TestCase.assertContainsRe.

When the constructor is deprecated, just say that the class is deprecated, not
the __init__ method - this works better with applyDeprecated in tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_xml.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
from cStringIO import StringIO
18
18
 
19
19
from bzrlib import (
20
 
    errors,
21
 
    fifo_cache,
22
 
    inventory,
23
 
    xml6,
 
20
    errors, 
 
21
    inventory, 
24
22
    xml7,
25
 
    xml8,
26
 
    serializer,
 
23
    xml_serializer,
27
24
    )
28
25
from bzrlib.tests import TestCase
29
26
from bzrlib.inventory import Inventory, InventoryEntry
82
79
"""
83
80
 
84
81
_committed_inv_v5 = """<inventory>
85
 
<file file_id="bar-20050901064931-73b4b1138abc9cd2"
86
 
      name="bar" parent_id="TREE_ROOT"
 
82
<file file_id="bar-20050901064931-73b4b1138abc9cd2" 
 
83
      name="bar" parent_id="TREE_ROOT" 
87
84
      revision="mbp@foo-123123"
88
85
      text_sha1="A" text_size="1"/>
89
86
<directory name="subdir"
90
87
           file_id="foo-20050801201819-4139aa4a272f4250"
91
 
           parent_id="TREE_ROOT"
 
88
           parent_id="TREE_ROOT" 
92
89
           revision="mbp@foo-00"/>
93
 
<file executable="yes" file_id="bar-20050824000535-6bc48cfad47ed134"
94
 
      name="bar" parent_id="foo-20050801201819-4139aa4a272f4250"
 
90
<file executable="yes" file_id="bar-20050824000535-6bc48cfad47ed134" 
 
91
      name="bar" parent_id="foo-20050801201819-4139aa4a272f4250" 
95
92
      revision="mbp@foo-00"
96
93
      text_sha1="B" text_size="0"/>
97
94
</inventory>
98
95
"""
99
96
 
100
97
_basis_inv_v5 = """<inventory revision_id="mbp@sourcefrog.net-20050905063503-43948f59fa127d92">
101
 
<file file_id="bar-20050901064931-73b4b1138abc9cd2"
102
 
      name="bar" parent_id="TREE_ROOT"
 
98
<file file_id="bar-20050901064931-73b4b1138abc9cd2" 
 
99
      name="bar" parent_id="TREE_ROOT" 
103
100
      revision="mbp@foo-123123"/>
104
101
<directory name="subdir"
105
102
           file_id="foo-20050801201819-4139aa4a272f4250"
106
 
           parent_id="TREE_ROOT"
 
103
           parent_id="TREE_ROOT" 
107
104
           revision="mbp@foo-00"/>
108
 
<file file_id="bar-20050824000535-6bc48cfad47ed134"
109
 
      name="bar" parent_id="foo-20050801201819-4139aa4a272f4250"
 
105
<file file_id="bar-20050824000535-6bc48cfad47ed134" 
 
106
      name="bar" parent_id="foo-20050801201819-4139aa4a272f4250" 
110
107
      revision="mbp@foo-00"/>
111
108
</inventory>
112
109
"""
141
138
</inventory>
142
139
"""
143
140
 
144
 
_expected_inv_v6 = """<inventory format="6" revision_id="rev_outer">
145
 
<directory file_id="tree-root-321" name="" revision="rev_outer" />
146
 
<directory file_id="dir-id" name="dir" parent_id="tree-root-321" revision="rev_outer" />
147
 
<file file_id="file-id" name="file" parent_id="tree-root-321" revision="rev_outer" text_sha1="A" text_size="1" />
148
 
<symlink file_id="link-id" name="link" parent_id="tree-root-321" revision="rev_outer" symlink_target="a" />
149
 
</inventory>
150
 
"""
151
 
 
152
141
_expected_inv_v7 = """<inventory format="7" revision_id="rev_outer">
153
142
<directory file_id="tree-root-321" name="" revision="rev_outer" />
154
143
<directory file_id="dir-id" name="dir" parent_id="tree-root-321" revision="rev_outer" />
158
147
</inventory>
159
148
"""
160
149
 
161
 
_expected_rev_v8 = """<revision committer="Martin Pool &lt;mbp@sourcefrog.net&gt;" format="8" inventory_sha1="e79c31c1deb64c163cf660fdedd476dd579ffd41" revision_id="mbp@sourcefrog.net-20050905080035-e0439293f8b6b9f9" timestamp="1125907235.212" timezone="36000">
162
 
<message>- start splitting code for xml (de)serialization away from objects
163
 
  preparatory to supporting multiple formats by a single library
164
 
</message>
165
 
<parents>
166
 
<revision_ref revision_id="mbp@sourcefrog.net-20050905063503-43948f59fa127d92" />
167
 
</parents>
168
 
</revision>
169
 
"""
170
 
 
171
 
_expected_inv_v8 = """<inventory format="8" revision_id="rev_outer">
172
 
<directory file_id="tree-root-321" name="" revision="rev_outer" />
173
 
<directory file_id="dir-id" name="dir" parent_id="tree-root-321" revision="rev_outer" />
174
 
<file file_id="file-id" name="file" parent_id="tree-root-321" revision="rev_outer" text_sha1="A" text_size="1" />
175
 
<symlink file_id="link-id" name="link" parent_id="tree-root-321" revision="rev_outer" symlink_target="a" />
176
 
</inventory>
177
 
"""
178
 
 
179
150
_revision_utf8_v5 = """<revision committer="Erik B&#229;gfors &lt;erik@foo.net&gt;"
180
151
    inventory_sha1="e79c31c1deb64c163cf660fdedd476dd579ffd41"
181
152
    revision_id="erik@b&#229;gfors-02"
204
175
</inventory>
205
176
"""
206
177
 
207
 
# Before revision_id was always stored as an attribute
208
 
_inventory_v5a = """<inventory format="5">
209
 
</inventory>
210
 
"""
211
 
 
212
 
# Before revision_id was always stored as an attribute
213
 
_inventory_v5b = """<inventory format="5" revision_id="a-rev-id">
214
 
</inventory>
215
 
"""
216
 
 
217
178
 
218
179
class TestSerializer(TestCase):
219
180
    """Test XML serialization"""
220
 
 
221
181
    def test_canned_inventory(self):
222
182
        """Test unpacked a canned inventory v4 file."""
223
183
        inp = StringIO(_working_inventory_v4)
286
246
        eq(ie.name, 'bar')
287
247
        eq(inv[ie.parent_id].kind, 'directory')
288
248
 
289
 
    def test_unpack_inventory_5a(self):
290
 
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(
291
 
                _inventory_v5a, revision_id='test-rev-id')
292
 
        self.assertEqual('test-rev-id', inv.root.revision)
293
 
 
294
 
    def test_unpack_inventory_5a_cache_and_copy(self):
295
 
        # Passing an entry_cache should get populated with the objects
296
 
        # But the returned objects should be copies if return_from_cache is
297
 
        # False
298
 
        entry_cache = fifo_cache.FIFOCache()
299
 
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(
300
 
            _inventory_v5a, revision_id='test-rev-id',
301
 
            entry_cache=entry_cache, return_from_cache=False)
302
 
        for entry in inv.iter_just_entries():
303
 
            key = (entry.file_id, entry.revision)
304
 
            if entry.file_id is inv.root.file_id:
305
 
                # The root id is inferred for xml v5
306
 
                self.assertFalse(key in entry_cache)
307
 
            else:
308
 
                self.assertIsNot(entry, entry_cache[key])
309
 
 
310
 
    def test_unpack_inventory_5a_cache_no_copy(self):
311
 
        # Passing an entry_cache should get populated with the objects
312
 
        # The returned objects should be exact if return_from_cache is
313
 
        # True
314
 
        entry_cache = fifo_cache.FIFOCache()
315
 
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(
316
 
            _inventory_v5a, revision_id='test-rev-id',
317
 
            entry_cache=entry_cache, return_from_cache=True)
318
 
        for entry in inv.iter_just_entries():
319
 
            key = (entry.file_id, entry.revision)
320
 
            if entry.file_id is inv.root.file_id:
321
 
                # The root id is inferred for xml v5
322
 
                self.assertFalse(key in entry_cache)
323
 
            else:
324
 
                self.assertIs(entry, entry_cache[key])
325
 
 
326
 
    def test_unpack_inventory_5b(self):
327
 
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(
328
 
                _inventory_v5b, revision_id='test-rev-id')
329
 
        self.assertEqual('a-rev-id', inv.root.revision)
330
 
 
331
249
    def test_repack_inventory_5(self):
332
250
        inp = StringIO(_committed_inv_v5)
333
251
        inv = bzrlib.xml5.serializer_v5.read_inventory(inp)
336
254
        self.assertEqualDiff(_expected_inv_v5, outp.getvalue())
337
255
        inv2 = bzrlib.xml5.serializer_v5.read_inventory(StringIO(outp.getvalue()))
338
256
        self.assertEqual(inv, inv2)
339
 
 
 
257
    
340
258
    def assertRoundTrips(self, xml_string):
341
259
        inp = StringIO(xml_string)
342
260
        inv = bzrlib.xml5.serializer_v5.read_inventory(inp)
391
309
        new_rev = s_v5.read_revision_from_string(txt)
392
310
        self.assertEqual(props, new_rev.properties)
393
311
 
394
 
    def get_sample_inventory(self):
 
312
    def test_roundtrip_inventory_v7(self):
395
313
        inv = Inventory('tree-root-321', revision_id='rev_outer')
 
314
        inv.add(inventory.TreeReference('nested-id', 'nested', 'tree-root-321',
 
315
                                        'rev_outer', 'rev_inner'))
396
316
        inv.add(inventory.InventoryFile('file-id', 'file', 'tree-root-321'))
397
 
        inv.add(inventory.InventoryDirectory('dir-id', 'dir',
 
317
        inv.add(inventory.InventoryDirectory('dir-id', 'dir', 
398
318
                                             'tree-root-321'))
399
319
        inv.add(inventory.InventoryLink('link-id', 'link', 'tree-root-321'))
400
320
        inv['tree-root-321'].revision = 'rev_outer'
404
324
        inv['file-id'].text_size = 1
405
325
        inv['link-id'].revision = 'rev_outer'
406
326
        inv['link-id'].symlink_target = 'a'
407
 
        return inv
408
 
 
409
 
    def test_roundtrip_inventory_v7(self):
410
 
        inv = self.get_sample_inventory()
411
 
        inv.add(inventory.TreeReference('nested-id', 'nested', 'tree-root-321',
412
 
                                        'rev_outer', 'rev_inner'))
413
327
        txt = xml7.serializer_v7.write_inventory_to_string(inv)
414
328
        lines = xml7.serializer_v7.write_inventory_to_lines(inv)
415
329
        self.assertEqual(bzrlib.osutils.split_lines(txt), lines)
419
333
        for path, ie in inv.iter_entries():
420
334
            self.assertEqual(ie, inv2[ie.file_id])
421
335
 
422
 
    def test_roundtrip_inventory_v6(self):
423
 
        inv = self.get_sample_inventory()
424
 
        txt = xml6.serializer_v6.write_inventory_to_string(inv)
425
 
        lines = xml6.serializer_v6.write_inventory_to_lines(inv)
426
 
        self.assertEqual(bzrlib.osutils.split_lines(txt), lines)
427
 
        self.assertEqualDiff(_expected_inv_v6, txt)
428
 
        inv2 = xml6.serializer_v6.read_inventory_from_string(txt)
429
 
        self.assertEqual(4, len(inv2))
430
 
        for path, ie in inv.iter_entries():
431
 
            self.assertEqual(ie, inv2[ie.file_id])
432
 
 
433
336
    def test_wrong_format_v7(self):
434
337
        """Can't accidentally open a file with wrong serializer"""
435
338
        s_v6 = bzrlib.xml6.serializer_v6
436
339
        s_v7 = xml7.serializer_v7
437
 
        self.assertRaises(errors.UnexpectedInventoryFormat,
 
340
        self.assertRaises(errors.UnexpectedInventoryFormat, 
438
341
                          s_v7.read_inventory_from_string, _expected_inv_v5)
439
 
        self.assertRaises(errors.UnexpectedInventoryFormat,
 
342
        self.assertRaises(errors.UnexpectedInventoryFormat, 
440
343
                          s_v6.read_inventory_from_string, _expected_inv_v7)
441
344
 
442
345
    def test_tree_reference(self):
458
361
        self.assertEqual('tree-root-321', inv2['nested-id'].parent_id)
459
362
        self.assertEqual('rev-outer', inv2['nested-id'].revision)
460
363
        self.assertEqual('rev-inner', inv2['nested-id'].reference_revision)
461
 
        self.assertRaises(errors.UnsupportedInventoryKind,
 
364
        self.assertRaises(errors.UnsupportedInventoryKind, 
462
365
                          s_v6.read_inventory_from_string,
463
366
                          txt.replace('format="7"', 'format="6"'))
464
 
        self.assertRaises(errors.UnsupportedInventoryKind,
 
367
        self.assertRaises(errors.UnsupportedInventoryKind, 
465
368
                          s_v5.read_inventory_from_string,
466
369
                          txt.replace('format="7"', 'format="5"'))
467
370
 
468
 
    def test_roundtrip_inventory_v8(self):
469
 
        inv = self.get_sample_inventory()
470
 
        txt = xml8.serializer_v8.write_inventory_to_string(inv)
471
 
        inv2 = xml8.serializer_v8.read_inventory_from_string(txt)
472
 
        self.assertEqual(4, len(inv2))
473
 
        for path, ie in inv.iter_entries():
474
 
            self.assertEqual(ie, inv2[ie.file_id])
475
 
 
476
 
    def test_inventory_text_v8(self):
477
 
        inv = self.get_sample_inventory()
478
 
        txt = xml8.serializer_v8.write_inventory_to_string(inv)
479
 
        lines = xml8.serializer_v8.write_inventory_to_lines(inv)
480
 
        self.assertEqual(bzrlib.osutils.split_lines(txt), lines)
481
 
        self.assertEqualDiff(_expected_inv_v8, txt)
482
 
 
483
 
    def test_revision_text_v6(self):
484
 
        """Pack revision to XML v6"""
485
 
        rev = bzrlib.xml6.serializer_v6.read_revision_from_string(
486
 
            _expected_rev_v5)
487
 
        serialized = bzrlib.xml6.serializer_v6.write_revision_to_string(rev)
488
 
        self.assertEqualDiff(serialized, _expected_rev_v5)
489
 
 
490
 
    def test_revision_text_v7(self):
491
 
        """Pack revision to XML v7"""
492
 
        rev = bzrlib.xml7.serializer_v7.read_revision_from_string(
493
 
            _expected_rev_v5)
494
 
        serialized = bzrlib.xml7.serializer_v7.write_revision_to_string(rev)
495
 
        self.assertEqualDiff(serialized, _expected_rev_v5)
496
 
 
497
 
    def test_revision_text_v8(self):
498
 
        """Pack revision to XML v8"""
499
 
        rev = bzrlib.xml8.serializer_v8.read_revision_from_string(
500
 
            _expected_rev_v8)
501
 
        serialized = bzrlib.xml8.serializer_v8.write_revision_to_string(rev)
502
 
        self.assertEqualDiff(serialized, _expected_rev_v8)
503
 
 
504
371
    def test_revision_ids_are_utf8(self):
505
372
        """Parsed revision_ids should all be utf-8 strings, not unicode."""
506
373
        s_v5 = bzrlib.xml5.serializer_v5
521
388
        fid_bar1 = u'b\xe5r-01'.encode('utf8')
522
389
        fid_sub = u's\xb5bdir-01'.encode('utf8')
523
390
        fid_bar2 = u'b\xe5r-02'.encode('utf8')
524
 
        expected = [(u'', fid_root, None, rev_id_2),
 
391
        expected = [(u'', fid_root, None, None),
525
392
                    (u'b\xe5r', fid_bar1, fid_root, rev_id_1),
526
393
                    (u's\xb5bdir', fid_sub, fid_root, rev_id_1),
527
394
                    (u's\xb5bdir/b\xe5r', fid_bar2, fid_sub, rev_id_2),
545
412
 
546
413
        self.assertEqual(len(expected), len(actual))
547
414
 
 
415
    def test_registry(self):
 
416
        self.assertIs(serializer_v4,
 
417
                      xml_serializer.format_registry.get('4'))
 
418
        self.assertIs(bzrlib.xml5.serializer_v5,
 
419
                      xml_serializer.format_registry.get('5'))
 
420
        self.assertIs(bzrlib.xml6.serializer_v6,
 
421
                      xml_serializer.format_registry.get('6'))
 
422
        self.assertIs(bzrlib.xml7.serializer_v7,
 
423
                      xml_serializer.format_registry.get('7'))
 
424
 
548
425
 
549
426
class TestEncodeAndEscape(TestCase):
550
427
    """Whitebox testing of the _encode_and_escape function."""
551
428
 
552
429
    def setUp(self):
553
 
        TestCase.setUp(self)
554
430
        # Keep the cache clear before and after the test
555
 
        bzrlib.xml8._ensure_utf8_re()
556
 
        bzrlib.xml8._clear_cache()
557
 
        self.addCleanup(bzrlib.xml8._clear_cache)
 
431
        bzrlib.xml5._ensure_utf8_re()
 
432
        bzrlib.xml5._clear_cache()
 
433
        self.addCleanup(bzrlib.xml5._clear_cache)
558
434
 
559
435
    def test_simple_ascii(self):
560
436
        # _encode_and_escape always appends a final ", because these parameters
561
437
        # are being used in xml attributes, and by returning it now, we have to
562
438
        # do fewer string operations later.
563
 
        val = bzrlib.xml8._encode_and_escape('foo bar')
 
439
        val = bzrlib.xml5._encode_and_escape('foo bar')
564
440
        self.assertEqual('foo bar"', val)
565
441
        # The second time should be cached
566
 
        val2 = bzrlib.xml8._encode_and_escape('foo bar')
 
442
        val2 = bzrlib.xml5._encode_and_escape('foo bar')
567
443
        self.assertIs(val2, val)
568
444
 
569
445
    def test_ascii_with_xml(self):
570
446
        self.assertEqual('&amp;&apos;&quot;&lt;&gt;"',
571
 
                         bzrlib.xml8._encode_and_escape('&\'"<>'))
 
447
                         bzrlib.xml5._encode_and_escape('&\'"<>'))
572
448
 
573
449
    def test_utf8_with_xml(self):
574
450
        # u'\xb5\xe5&\u062c'
575
451
        utf8_str = '\xc2\xb5\xc3\xa5&\xd8\xac'
576
452
        self.assertEqual('&#181;&#229;&amp;&#1580;"',
577
 
                         bzrlib.xml8._encode_and_escape(utf8_str))
 
453
                         bzrlib.xml5._encode_and_escape(utf8_str))
578
454
 
579
455
    def test_unicode(self):
580
456
        uni_str = u'\xb5\xe5&\u062c'
581
457
        self.assertEqual('&#181;&#229;&amp;&#1580;"',
582
 
                         bzrlib.xml8._encode_and_escape(uni_str))
 
458
                         bzrlib.xml5._encode_and_escape(uni_str))