/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_errors.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_errors.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
 
2
#   Authors: Robert Collins <robert.collins@canonical.com>
 
3
#            and others
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
12
14
#
13
15
# You should have received a copy of the GNU General Public License
14
16
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
18
 
17
19
"""Tests for the formatting and construction of errors."""
18
20
 
19
 
import socket
20
 
import sys
21
 
 
22
21
from bzrlib import (
23
22
    bzrdir,
24
23
    errors,
25
 
    osutils,
26
24
    symbol_versioning,
27
 
    urlutils,
28
25
    )
29
26
from bzrlib.tests import TestCase, TestCaseWithTransport
30
27
 
31
28
 
 
29
 
32
30
class TestErrors(TestCaseWithTransport):
33
31
 
34
 
    def test_bad_filename_encoding(self):
35
 
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
36
 
        self.assertEqualDiff(
37
 
            "Filename 'bad/filen\\xe5me' is not valid in your current"
38
 
            " filesystem encoding UTF-8",
39
 
            str(error))
40
 
 
41
 
    def test_corrupt_dirstate(self):
42
 
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
43
 
        self.assertEqualDiff(
44
 
            "Inconsistency in dirstate file path/to/dirstate.\n"
45
 
            "Error: the reason why",
46
 
            str(error))
47
 
 
48
 
    def test_dirstate_corrupt(self):
49
 
        error = errors.DirstateCorrupt('.bzr/checkout/dirstate',
50
 
                                       'trailing garbage: "x"')
51
 
        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
52
 
            " appears to be corrupt: trailing garbage: \"x\"",
53
 
            str(error))
54
 
 
55
32
    def test_disabled_method(self):
56
33
        error = errors.DisabledMethod("class name")
57
34
        self.assertEqualDiff(
67
44
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
68
45
            str(error))
69
46
 
70
 
    def test_ghost_revisions_have_no_revno(self):
71
 
        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
72
 
        self.assertEqualDiff("Could not determine revno for {target} because"
73
 
                             " its ancestry shows a ghost at {ghost_rev}",
74
 
                             str(error))
75
 
 
76
47
    def test_incompatibleAPI(self):
77
48
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
78
49
        self.assertEqualDiff(
80
51
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
81
52
            str(error))
82
53
 
83
 
    def test_inconsistent_delta(self):
84
 
        error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
85
 
        self.assertEqualDiff(
86
 
            "An inconsistent delta was supplied involving 'path', 'file-id'\n"
87
 
            "reason: reason for foo",
88
 
            str(error))
89
 
 
90
 
    def test_inconsistent_delta_delta(self):
91
 
        error = errors.InconsistentDeltaDelta([], 'reason')
92
 
        self.assertEqualDiff(
93
 
            "An inconsistent delta was supplied: []\nreason: reason",
94
 
            str(error))
95
 
 
96
54
    def test_in_process_transport(self):
97
55
        error = errors.InProcessTransport('fpp')
98
56
        self.assertEqualDiff(
99
57
            "The transport 'fpp' is only accessible within this process.",
100
58
            str(error))
101
59
 
102
 
    def test_invalid_http_range(self):
103
 
        error = errors.InvalidHttpRange('path',
104
 
                                        'Content-Range: potatoes 0-00/o0oo0',
105
 
                                        'bad range')
106
 
        self.assertEquals("Invalid http range"
107
 
                          " 'Content-Range: potatoes 0-00/o0oo0'"
108
 
                          " for path: bad range",
109
 
                          str(error))
110
 
 
111
 
    def test_invalid_range(self):
112
 
        error = errors.InvalidRange('path', 12, 'bad range')
113
 
        self.assertEquals("Invalid range access in path at 12: bad range",
114
 
                          str(error))
115
 
 
116
60
    def test_inventory_modified(self):
117
61
        error = errors.InventoryModified("a tree to be repred")
118
62
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
120
64
            "read without data loss.",
121
65
            str(error))
122
66
 
123
 
    def test_jail_break(self):
124
 
        error = errors.JailBreak("some url")
125
 
        self.assertEqualDiff("An attempt to access a url outside the server"
126
 
            " jail was made: 'some url'.",
127
 
            str(error))
 
67
    def test_install_failed(self):
 
68
        error = errors.InstallFailed(['rev-one'])
 
69
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
 
70
        error = errors.InstallFailed(['rev-one', 'rev-two'])
 
71
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
 
72
                         str(error))
 
73
        error = errors.InstallFailed([None])
 
74
        self.assertEqual("Could not install revisions:\nNone", str(error))
128
75
 
129
76
    def test_lock_active(self):
130
77
        error = errors.LockActive("lock description")
139
86
                         '"stream format" into knit of format '
140
87
                         '"target format".', str(error))
141
88
 
142
 
    def test_knit_data_stream_unknown(self):
143
 
        error = errors.KnitDataStreamUnknown(
144
 
            'stream format')
145
 
        self.assertEqual('Cannot parse knit data stream of format '
146
 
                         '"stream format".', str(error))
147
 
 
148
89
    def test_knit_header_error(self):
149
90
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
150
91
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
161
102
        error = errors.MediumNotConnected("a medium")
162
103
        self.assertEqualDiff(
163
104
            "The medium 'a medium' is not connected.", str(error))
164
 
 
165
 
    def test_no_public_branch(self):
166
 
        b = self.make_branch('.')
167
 
        error = errors.NoPublicBranch(b)
168
 
        url = urlutils.unescape_for_display(b.base, 'ascii')
169
 
        self.assertEqualDiff(
170
 
            'There is no public branch set for "%s".' % url, str(error))
171
 
 
 
105
        
172
106
    def test_no_repo(self):
173
107
        dir = bzrdir.BzrDir.create(self.get_url())
174
108
        error = errors.NoRepositoryPresent(dir)
175
109
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
176
110
        self.assertEqual(-1, str(error).find((dir.transport.base)))
177
 
 
 
111
        
178
112
    def test_no_smart_medium(self):
179
113
        error = errors.NoSmartMedium("a transport")
180
114
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
199
133
                             " tree atree.", str(error))
200
134
        self.assertIsInstance(error, errors.NoSuchRevision)
201
135
 
202
 
    def test_not_stacked(self):
203
 
        error = errors.NotStacked('a branch')
204
 
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
205
 
            str(error))
206
 
 
207
136
    def test_not_write_locked(self):
208
137
        error = errors.NotWriteLocked('a thing to repr')
209
138
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
210
139
            "to be.",
211
140
            str(error))
212
141
 
 
142
    def test_read_only_lock_error(self):
 
143
        error = self.applyDeprecated(symbol_versioning.zero_ninetytwo,
 
144
            errors.ReadOnlyLockError, 'filename', 'error message')
 
145
        self.assertEqualDiff("Cannot acquire write lock on filename."
 
146
                             " error message", str(error))
 
147
 
213
148
    def test_lock_failed(self):
214
149
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
215
150
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
223
158
            "the currently open request.",
224
159
            str(error))
225
160
 
226
 
    def test_unavailable_representation(self):
227
 
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
228
 
        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
229
 
            "('key',) which is encoded as 'fulltext'.",
230
 
            str(error))
231
 
 
232
161
    def test_unknown_hook(self):
233
162
        error = errors.UnknownHook("branch", "foo")
234
163
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
239
168
            " of bzrlib.",
240
169
            str(error))
241
170
 
242
 
    def test_unstackable_branch_format(self):
243
 
        format = u'foo'
244
 
        url = "/foo"
245
 
        error = errors.UnstackableBranchFormat(format, url)
246
 
        self.assertEqualDiff(
247
 
            "The branch '/foo'(foo) is not a stackable format. "
248
 
            "You will need to upgrade the branch to permit branch stacking.",
249
 
            str(error))
250
 
 
251
 
    def test_unstackable_location(self):
252
 
        error = errors.UnstackableLocationError('foo', 'bar')
253
 
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
254
 
            str(error))
255
 
 
256
 
    def test_unstackable_repository_format(self):
257
 
        format = u'foo'
258
 
        url = "/foo"
259
 
        error = errors.UnstackableRepositoryFormat(format, url)
260
 
        self.assertEqualDiff(
261
 
            "The repository '/foo'(foo) is not a stackable format. "
262
 
            "You will need to upgrade the repository to permit branch stacking.",
263
 
            str(error))
264
 
 
265
171
    def test_up_to_date(self):
266
172
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
267
 
        self.assertEqualDiff("The branch format All-in-one "
268
 
                             "format 4 is already at the most "
 
173
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
 
174
                             "format 0.0.4 is already at the most "
269
175
                             "recent format.",
270
176
                             str(error))
271
177
 
399
305
            host='ahost', port=444, msg='Unable to connect to ssh host',
400
306
            orig_error='my_error')
401
307
 
402
 
    def test_target_not_branch(self):
403
 
        """Test the formatting of TargetNotBranch."""
404
 
        error = errors.TargetNotBranch('foo')
405
 
        self.assertEqual(
406
 
            "Your branch does not have all of the revisions required in "
407
 
            "order to merge this merge directive and the target "
408
 
            "location specified in the merge directive is not a branch: "
409
 
            "foo.", str(error))
410
 
 
411
308
    def test_malformed_bug_identifier(self):
412
309
        """Test the formatting of MalformedBugIdentifier."""
413
310
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
414
311
        self.assertEqual(
415
 
            'Did not understand bug identifier bogus: reason for bogosity. '
416
 
            'See "bzr help bugs" for more information on this feature.',
 
312
            "Did not understand bug identifier bogus: reason for bogosity",
417
313
            str(error))
418
314
 
419
315
    def test_unknown_bug_tracker_abbreviation(self):
470
366
        self.assertEqual(
471
367
            "Container has multiple records with the same name: n\xc3\xa5me",
472
368
            str(e))
473
 
 
 
369
        
474
370
    def test_check_error(self):
475
371
        # This has a member called 'message', which is problematic in
476
372
        # python2.5 because that is a slot on the base Exception class
480
376
            str(e))
481
377
        self.assertTrue(e.internal_error)
482
378
 
483
 
    def test_repository_data_stream_error(self):
484
 
        """Test the formatting of RepositoryDataStreamError."""
485
 
        e = errors.RepositoryDataStreamError(u"my reason")
486
 
        self.assertEqual(
487
 
            "Corrupt or incompatible data stream: my reason", str(e))
488
 
 
489
 
    def test_immortal_pending_deletion_message(self):
490
 
        err = errors.ImmortalPendingDeletion('foo')
491
 
        self.assertEquals(
492
 
            "Unable to delete transform temporary directory foo.  "
493
 
            "Please examine foo to see if it contains any files "
494
 
            "you wish to keep, and delete it when you are done.",
495
 
            str(err))
496
 
 
497
 
    def test_unable_create_symlink(self):
498
 
        err = errors.UnableCreateSymlink()
499
 
        self.assertEquals(
500
 
            "Unable to create symlink on this platform",
501
 
            str(err))
502
 
        err = errors.UnableCreateSymlink(path=u'foo')
503
 
        self.assertEquals(
504
 
            "Unable to create symlink 'foo' on this platform",
505
 
            str(err))
506
 
        err = errors.UnableCreateSymlink(path=u'\xb5')
507
 
        self.assertEquals(
508
 
            "Unable to create symlink u'\\xb5' on this platform",
509
 
            str(err))
510
 
 
511
 
    def test_invalid_url_join(self):
512
 
        """Test the formatting of InvalidURLJoin."""
513
 
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
514
 
        self.assertEqual(
515
 
            "Invalid URL join request: Reason: 'base path' + ('args',)",
516
 
            str(e))
517
 
 
518
 
    def test_incorrect_url(self):
519
 
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
520
 
        self.assertEquals(
521
 
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
522
 
             "http://bug.com/"),
523
 
            str(err))
524
 
 
525
 
    def test_unable_encode_path(self):
526
 
        err = errors.UnableEncodePath('foo', 'executable')
527
 
        self.assertEquals("Unable to encode executable path 'foo' in "
528
 
            "user encoding " + osutils.get_user_encoding(),
529
 
            str(err))
530
 
 
531
 
    def test_unknown_format(self):
532
 
        err = errors.UnknownFormatError('bar', kind='foo')
533
 
        self.assertEquals("Unknown foo format: 'bar'", str(err))
534
 
 
535
 
    def test_unknown_rules(self):
536
 
        err = errors.UnknownRules(['foo', 'bar'])
537
 
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
538
 
 
539
 
    def test_hook_failed(self):
540
 
        # Create an exc_info tuple by raising and catching an exception.
541
 
        try:
542
 
            1/0
543
 
        except ZeroDivisionError:
544
 
            exc_info = sys.exc_info()
545
 
        err = errors.HookFailed('hook stage', 'hook name', exc_info, warn=False)
546
 
        self.assertStartsWith(
547
 
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
548
 
        self.assertEndsWith(
549
 
            str(err), 'integer division or modulo by zero')
550
 
 
551
 
    def test_tip_change_rejected(self):
552
 
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
553
 
        self.assertEquals(
554
 
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
555
 
            unicode(err))
556
 
        self.assertEquals(
557
 
            'Tip change rejected: Unicode message\xe2\x80\xbd',
558
 
            str(err))
559
 
 
560
 
    def test_error_from_smart_server(self):
561
 
        error_tuple = ('error', 'tuple')
562
 
        err = errors.ErrorFromSmartServer(error_tuple)
563
 
        self.assertEquals(
564
 
            "Error received from smart server: ('error', 'tuple')", str(err))
565
 
 
566
 
    def test_untranslateable_error_from_smart_server(self):
567
 
        error_tuple = ('error', 'tuple')
568
 
        orig_err = errors.ErrorFromSmartServer(error_tuple)
569
 
        err = errors.UnknownErrorFromSmartServer(orig_err)
570
 
        self.assertEquals(
571
 
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
572
 
 
573
 
    def test_smart_message_handler_error(self):
574
 
        # Make an exc_info tuple.
575
 
        try:
576
 
            raise Exception("example error")
577
 
        except Exception:
578
 
            exc_info = sys.exc_info()
579
 
        err = errors.SmartMessageHandlerError(exc_info)
580
 
        self.assertStartsWith(
581
 
            str(err), "The message handler raised an exception:\n")
582
 
        self.assertEndsWith(str(err), "Exception: example error\n")
583
 
 
584
 
    def test_must_have_working_tree(self):
585
 
        err = errors.MustHaveWorkingTree('foo', 'bar')
586
 
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
587
 
                                   " working tree.")
588
 
 
589
 
    def test_no_such_view(self):
590
 
        err = errors.NoSuchView('foo')
591
 
        self.assertEquals("No such view: foo.", str(err))
592
 
 
593
 
    def test_views_not_supported(self):
594
 
        err = errors.ViewsNotSupported('atree')
595
 
        err_str = str(err)
596
 
        self.assertStartsWith(err_str, "Views are not supported by ")
597
 
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
598
 
            "tree to a later format.")
599
 
 
600
 
    def test_file_outside_view(self):
601
 
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
602
 
        self.assertEquals('Specified file "baz" is outside the current view: '
603
 
            'foo, bar', str(err))
604
 
 
605
 
    def test_invalid_shelf_id(self):
606
 
        invalid_id = "foo"
607
 
        err = errors.InvalidShelfId(invalid_id)
608
 
        self.assertEqual('"foo" is not a valid shelf id, '
609
 
            'try a number instead.', str(err))
610
 
 
611
 
    def test_unresumable_write_group(self):
612
 
        repo = "dummy repo"
613
 
        wg_tokens = ['token']
614
 
        reason = "a reason"
615
 
        err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
616
 
        self.assertEqual(
617
 
            "Repository dummy repo cannot resume write group "
618
 
            "['token']: a reason", str(err))
619
 
 
620
 
    def test_unsuspendable_write_group(self):
621
 
        repo = "dummy repo"
622
 
        err = errors.UnsuspendableWriteGroup(repo)
623
 
        self.assertEqual(
624
 
            'Repository dummy repo cannot suspend a write group.', str(err))
625
 
 
626
 
    def test_not_branch_no_args(self):
627
 
        err = errors.NotBranchError('path')
628
 
        self.assertEqual('Not a branch: "path".', str(err))
629
 
 
630
 
    def test_not_branch_bzrdir_with_repo(self):
631
 
        bzrdir = self.make_repository('repo').bzrdir
632
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
633
 
        self.assertEqual(
634
 
            'Not a branch: "path": location is a repository.', str(err))
635
 
 
636
 
    def test_not_branch_bzrdir_without_repo(self):
637
 
        bzrdir = self.make_bzrdir('bzrdir')
638
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
639
 
        self.assertEqual('Not a branch: "path".', str(err))
640
 
 
641
 
    def test_not_branch_laziness(self):
642
 
        real_bzrdir = self.make_bzrdir('path')
643
 
        class FakeBzrDir(object):
644
 
            def __init__(self):
645
 
                self.calls = []
646
 
            def open_repository(self):
647
 
                self.calls.append('open_repository')
648
 
                raise errors.NoRepositoryPresent(real_bzrdir)
649
 
        fake_bzrdir = FakeBzrDir()
650
 
        err = errors.NotBranchError('path', bzrdir=fake_bzrdir)
651
 
        self.assertEqual([], fake_bzrdir.calls)
652
 
        str(err)
653
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
654
 
        # Stringifying twice doesn't try to open a repository twice.
655
 
        str(err)
656
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
657
 
 
658
379
 
659
380
class PassThroughError(errors.BzrError):
660
 
 
 
381
    
661
382
    _fmt = """Pass through %(foo)s and %(bar)s"""
662
383
 
663
384
    def __init__(self, foo, bar):
670
391
 
671
392
 
672
393
class ErrorWithNoFormat(errors.BzrError):
673
 
    __doc__ = """This class has a docstring but no format string."""
 
394
    """This class has a docstring but no format string."""
674
395
 
675
396
 
676
397
class TestErrorFormatting(TestCase):
677
 
 
 
398
    
678
399
    def test_always_str(self):
679
400
        e = PassThroughError(u'\xb5', 'bar')
680
401
        self.assertIsInstance(e.__str__(), str)
691
412
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
692
413
                lambda x: str(x), e)
693
414
        ## s = str(e)
694
 
        self.assertEqual(s,
 
415
        self.assertEqual(s, 
695
416
                "This class has a docstring but no format string.")
696
417
 
697
418
    def test_mismatched_format_args(self):
701
422
        e = ErrorWithBadFormat(not_thing='x')
702
423
        self.assertStartsWith(
703
424
            str(e), 'Unprintable exception ErrorWithBadFormat')
704
 
 
705
 
    def test_cannot_bind_address(self):
706
 
        # see <https://bugs.edge.launchpad.net/bzr/+bug/286871>
707
 
        e = errors.CannotBindAddress('example.com', 22,
708
 
            socket.error(13, 'Permission denied'))
709
 
        self.assertContainsRe(str(e),
710
 
            r'Cannot bind address "example\.com:22":.*Permission denied')
711
 
 
712
 
    def test_file_timestamp_unavailable(self):            
713
 
        e = errors.FileTimestampUnavailable("/path/foo")
714
 
        self.assertEquals("The filestamp for /path/foo is not available.",
715
 
            str(e))