← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

  • Committer: Jelmer Vernooij
  • Date: 2008-06-11 18:58:19 UTC
  • mto: (3649.3.2 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 3658.
  • Revision ID: jelmer@samba.org-20080611185819-o4shi1ranh9zh01e
Move ftp transport into separate directory.

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, 2008 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 inspect
20
 
import re
21
 
import socket
22
 
import sys
23
 
 
24
21
from bzrlib import (
25
22
    bzrdir,
26
23
    errors,
28
25
    symbol_versioning,
29
26
    urlutils,
30
27
    )
31
 
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
28
from bzrlib.tests import TestCase, TestCaseWithTransport
32
29
 
33
30
 
34
31
class TestErrors(TestCaseWithTransport):
35
32
 
36
 
    def test_no_arg_named_message(self):
37
 
        """Ensure the __init__ and _fmt in errors do not have "message" arg.
38
 
 
39
 
        This test fails if __init__ or _fmt in errors has an argument
40
 
        named "message" as this can cause errors in some Python versions.
41
 
        Python 2.5 uses a slot for StandardError.message.
42
 
        See bug #603461
43
 
        """
44
 
        fmt_pattern = re.compile("%\(message\)[sir]")
45
 
        subclasses_present = getattr(errors.BzrError, '__subclasses__', None)
46
 
        if not subclasses_present:
47
 
            raise TestSkipped('__subclasses__ attribute required for classes. '
48
 
                'Requires Python 2.5 or later.')
49
 
        for c in errors.BzrError.__subclasses__():
50
 
            init = getattr(c, '__init__', None)
51
 
            fmt = getattr(c, '_fmt', None)
52
 
            if init:
53
 
                args = inspect.getargspec(init)[0]
54
 
                self.assertFalse('message' in args,
55
 
                    ('Argument name "message" not allowed for '
56
 
                    '"errors.%s.__init__"' % c.__name__))
57
 
            if fmt and fmt_pattern.search(fmt):
58
 
                self.assertFalse(True, ('"message" not allowed in '
59
 
                    '"errors.%s._fmt"' % c.__name__))
60
 
 
61
 
    def test_bad_filename_encoding(self):
62
 
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
63
 
        self.assertEqualDiff(
64
 
            "Filename 'bad/filen\\xe5me' is not valid in your current"
65
 
            " filesystem encoding UTF-8",
66
 
            str(error))
67
 
 
68
33
    def test_corrupt_dirstate(self):
69
34
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
70
35
        self.assertEqualDiff(
72
37
            "Error: the reason why",
73
38
            str(error))
74
39
 
75
 
    def test_dirstate_corrupt(self):
76
 
        error = errors.DirstateCorrupt('.bzr/checkout/dirstate',
77
 
                                       'trailing garbage: "x"')
78
 
        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
79
 
            " appears to be corrupt: trailing garbage: \"x\"",
80
 
            str(error))
81
 
 
82
40
    def test_disabled_method(self):
83
41
        error = errors.DisabledMethod("class name")
84
42
        self.assertEqualDiff(
94
52
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
95
53
            str(error))
96
54
 
97
 
    def test_ghost_revisions_have_no_revno(self):
98
 
        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
99
 
        self.assertEqualDiff("Could not determine revno for {target} because"
100
 
                             " its ancestry shows a ghost at {ghost_rev}",
101
 
                             str(error))
102
 
 
103
55
    def test_incompatibleAPI(self):
104
56
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
105
57
        self.assertEqualDiff(
114
66
            "reason: reason for foo",
115
67
            str(error))
116
68
 
117
 
    def test_inconsistent_delta_delta(self):
118
 
        error = errors.InconsistentDeltaDelta([], 'reason')
119
 
        self.assertEqualDiff(
120
 
            "An inconsistent delta was supplied: []\nreason: reason",
121
 
            str(error))
122
 
 
123
69
    def test_in_process_transport(self):
124
70
        error = errors.InProcessTransport('fpp')
125
71
        self.assertEqualDiff(
147
93
            "read without data loss.",
148
94
            str(error))
149
95
 
150
 
    def test_jail_break(self):
151
 
        error = errors.JailBreak("some url")
152
 
        self.assertEqualDiff("An attempt to access a url outside the server"
153
 
            " jail was made: 'some url'.",
154
 
            str(error))
 
96
    def test_install_failed(self):
 
97
        error = errors.InstallFailed(['rev-one'])
 
98
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
 
99
        error = errors.InstallFailed(['rev-one', 'rev-two'])
 
100
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
 
101
                         str(error))
 
102
        error = errors.InstallFailed([None])
 
103
        self.assertEqual("Could not install revisions:\nNone", str(error))
155
104
 
156
105
    def test_lock_active(self):
157
106
        error = errors.LockActive("lock description")
188
137
        error = errors.MediumNotConnected("a medium")
189
138
        self.assertEqualDiff(
190
139
            "The medium 'a medium' is not connected.", str(error))
191
 
 
 
140
 
192
141
    def test_no_public_branch(self):
193
142
        b = self.make_branch('.')
194
143
        error = errors.NoPublicBranch(b)
201
150
        error = errors.NoRepositoryPresent(dir)
202
151
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
203
152
        self.assertEqual(-1, str(error).find((dir.transport.base)))
204
 
 
 
153
        
205
154
    def test_no_smart_medium(self):
206
155
        error = errors.NoSmartMedium("a transport")
207
156
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
226
175
                             " tree atree.", str(error))
227
176
        self.assertIsInstance(error, errors.NoSuchRevision)
228
177
 
229
 
    def test_not_stacked(self):
230
 
        error = errors.NotStacked('a branch')
231
 
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
232
 
            str(error))
233
 
 
234
178
    def test_not_write_locked(self):
235
179
        error = errors.NotWriteLocked('a thing to repr')
236
180
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
237
181
            "to be.",
238
182
            str(error))
239
183
 
 
184
    def test_read_only_lock_error(self):
 
185
        error = self.applyDeprecated(symbol_versioning.zero_ninetytwo,
 
186
            errors.ReadOnlyLockError, 'filename', 'error message')
 
187
        self.assertEqualDiff("Cannot acquire write lock on filename."
 
188
                             " error message", str(error))
 
189
 
240
190
    def test_lock_failed(self):
241
191
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
242
192
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
250
200
            "the currently open request.",
251
201
            str(error))
252
202
 
253
 
    def test_unavailable_representation(self):
254
 
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
255
 
        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
256
 
            "('key',) which is encoded as 'fulltext'.",
257
 
            str(error))
258
 
 
259
203
    def test_unknown_hook(self):
260
204
        error = errors.UnknownHook("branch", "foo")
261
205
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
266
210
            " of bzrlib.",
267
211
            str(error))
268
212
 
269
 
    def test_unstackable_branch_format(self):
270
 
        format = u'foo'
271
 
        url = "/foo"
272
 
        error = errors.UnstackableBranchFormat(format, url)
273
 
        self.assertEqualDiff(
274
 
            "The branch '/foo'(foo) is not a stackable format. "
275
 
            "You will need to upgrade the branch to permit branch stacking.",
276
 
            str(error))
277
 
 
278
 
    def test_unstackable_location(self):
279
 
        error = errors.UnstackableLocationError('foo', 'bar')
280
 
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
281
 
            str(error))
282
 
 
283
 
    def test_unstackable_repository_format(self):
284
 
        format = u'foo'
285
 
        url = "/foo"
286
 
        error = errors.UnstackableRepositoryFormat(format, url)
287
 
        self.assertEqualDiff(
288
 
            "The repository '/foo'(foo) is not a stackable format. "
289
 
            "You will need to upgrade the repository to permit branch stacking.",
290
 
            str(error))
291
 
 
292
213
    def test_up_to_date(self):
293
214
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
294
 
        self.assertEqualDiff("The branch format All-in-one "
295
 
                             "format 4 is already at the most "
 
215
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
 
216
                             "format 0.0.4 is already at the most "
296
217
                             "recent format.",
297
218
                             str(error))
298
219
 
426
347
            host='ahost', port=444, msg='Unable to connect to ssh host',
427
348
            orig_error='my_error')
428
349
 
429
 
    def test_target_not_branch(self):
430
 
        """Test the formatting of TargetNotBranch."""
431
 
        error = errors.TargetNotBranch('foo')
432
 
        self.assertEqual(
433
 
            "Your branch does not have all of the revisions required in "
434
 
            "order to merge this merge directive and the target "
435
 
            "location specified in the merge directive is not a branch: "
436
 
            "foo.", str(error))
437
 
 
438
350
    def test_malformed_bug_identifier(self):
439
351
        """Test the formatting of MalformedBugIdentifier."""
440
352
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
441
353
        self.assertEqual(
442
 
            'Did not understand bug identifier bogus: reason for bogosity. '
443
 
            'See "bzr help bugs" for more information on this feature.',
 
354
            "Did not understand bug identifier bogus: reason for bogosity",
444
355
            str(error))
445
356
 
446
357
    def test_unknown_bug_tracker_abbreviation(self):
497
408
        self.assertEqual(
498
409
            "Container has multiple records with the same name: n\xc3\xa5me",
499
410
            str(e))
500
 
 
 
411
        
501
412
    def test_check_error(self):
502
413
        # This has a member called 'message', which is problematic in
503
414
        # python2.5 because that is a slot on the base Exception class
559
470
        err = errors.UnknownFormatError('bar', kind='foo')
560
471
        self.assertEquals("Unknown foo format: 'bar'", str(err))
561
472
 
562
 
    def test_unknown_rules(self):
563
 
        err = errors.UnknownRules(['foo', 'bar'])
564
 
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
565
 
 
566
 
    def test_hook_failed(self):
567
 
        # Create an exc_info tuple by raising and catching an exception.
568
 
        try:
569
 
            1/0
570
 
        except ZeroDivisionError:
571
 
            exc_info = sys.exc_info()
572
 
        err = errors.HookFailed('hook stage', 'hook name', exc_info, warn=False)
573
 
        self.assertStartsWith(
574
 
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
575
 
        self.assertEndsWith(
576
 
            str(err), 'integer division or modulo by zero')
577
 
 
578
 
    def test_tip_change_rejected(self):
579
 
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
580
 
        self.assertEquals(
581
 
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
582
 
            unicode(err))
583
 
        self.assertEquals(
584
 
            'Tip change rejected: Unicode message\xe2\x80\xbd',
585
 
            str(err))
586
 
 
587
 
    def test_error_from_smart_server(self):
588
 
        error_tuple = ('error', 'tuple')
589
 
        err = errors.ErrorFromSmartServer(error_tuple)
590
 
        self.assertEquals(
591
 
            "Error received from smart server: ('error', 'tuple')", str(err))
592
 
 
593
 
    def test_untranslateable_error_from_smart_server(self):
594
 
        error_tuple = ('error', 'tuple')
595
 
        orig_err = errors.ErrorFromSmartServer(error_tuple)
596
 
        err = errors.UnknownErrorFromSmartServer(orig_err)
597
 
        self.assertEquals(
598
 
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
599
 
 
600
 
    def test_smart_message_handler_error(self):
601
 
        # Make an exc_info tuple.
602
 
        try:
603
 
            raise Exception("example error")
604
 
        except Exception:
605
 
            exc_info = sys.exc_info()
606
 
        err = errors.SmartMessageHandlerError(exc_info)
607
 
        self.assertStartsWith(
608
 
            str(err), "The message handler raised an exception:\n")
609
 
        self.assertEndsWith(str(err), "Exception: example error\n")
610
 
 
611
 
    def test_must_have_working_tree(self):
612
 
        err = errors.MustHaveWorkingTree('foo', 'bar')
613
 
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
614
 
                                   " working tree.")
615
 
 
616
 
    def test_no_such_view(self):
617
 
        err = errors.NoSuchView('foo')
618
 
        self.assertEquals("No such view: foo.", str(err))
619
 
 
620
 
    def test_views_not_supported(self):
621
 
        err = errors.ViewsNotSupported('atree')
622
 
        err_str = str(err)
623
 
        self.assertStartsWith(err_str, "Views are not supported by ")
624
 
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
625
 
            "tree to a later format.")
626
 
 
627
 
    def test_file_outside_view(self):
628
 
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
629
 
        self.assertEquals('Specified file "baz" is outside the current view: '
630
 
            'foo, bar', str(err))
631
 
 
632
 
    def test_invalid_shelf_id(self):
633
 
        invalid_id = "foo"
634
 
        err = errors.InvalidShelfId(invalid_id)
635
 
        self.assertEqual('"foo" is not a valid shelf id, '
636
 
            'try a number instead.', str(err))
637
 
 
638
 
    def test_unresumable_write_group(self):
639
 
        repo = "dummy repo"
640
 
        wg_tokens = ['token']
641
 
        reason = "a reason"
642
 
        err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
643
 
        self.assertEqual(
644
 
            "Repository dummy repo cannot resume write group "
645
 
            "['token']: a reason", str(err))
646
 
 
647
 
    def test_unsuspendable_write_group(self):
648
 
        repo = "dummy repo"
649
 
        err = errors.UnsuspendableWriteGroup(repo)
650
 
        self.assertEqual(
651
 
            'Repository dummy repo cannot suspend a write group.', str(err))
652
 
 
653
 
    def test_not_branch_no_args(self):
654
 
        err = errors.NotBranchError('path')
655
 
        self.assertEqual('Not a branch: "path".', str(err))
656
 
 
657
 
    def test_not_branch_bzrdir_with_repo(self):
658
 
        bzrdir = self.make_repository('repo').bzrdir
659
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
660
 
        self.assertEqual(
661
 
            'Not a branch: "path": location is a repository.', str(err))
662
 
 
663
 
    def test_not_branch_bzrdir_without_repo(self):
664
 
        bzrdir = self.make_bzrdir('bzrdir')
665
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
666
 
        self.assertEqual('Not a branch: "path".', str(err))
667
 
 
668
 
    def test_not_branch_laziness(self):
669
 
        real_bzrdir = self.make_bzrdir('path')
670
 
        class FakeBzrDir(object):
671
 
            def __init__(self):
672
 
                self.calls = []
673
 
            def open_repository(self):
674
 
                self.calls.append('open_repository')
675
 
                raise errors.NoRepositoryPresent(real_bzrdir)
676
 
        fake_bzrdir = FakeBzrDir()
677
 
        err = errors.NotBranchError('path', bzrdir=fake_bzrdir)
678
 
        self.assertEqual([], fake_bzrdir.calls)
679
 
        str(err)
680
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
681
 
        # Stringifying twice doesn't try to open a repository twice.
682
 
        str(err)
683
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
684
 
 
685
 
    def test_invalid_pattern(self):
686
 
        error = errors.InvalidPattern('Bad pattern msg.')
687
 
        self.assertEqualDiff("Invalid pattern(s) found. Bad pattern msg.",
688
 
            str(error))
689
 
 
690
 
    def test_recursive_bind(self):
691
 
        error = errors.RecursiveBind('foo_bar_branch')
692
 
        msg = ('Branch "foo_bar_branch" appears to be bound to itself. '
693
 
            'Please use `bzr unbind` to fix.')
694
 
        self.assertEqualDiff(msg, str(error))
695
 
 
696
473
 
697
474
class PassThroughError(errors.BzrError):
698
 
 
 
475
    
699
476
    _fmt = """Pass through %(foo)s and %(bar)s"""
700
477
 
701
478
    def __init__(self, foo, bar):
708
485
 
709
486
 
710
487
class ErrorWithNoFormat(errors.BzrError):
711
 
    __doc__ = """This class has a docstring but no format string."""
 
488
    """This class has a docstring but no format string."""
712
489
 
713
490
 
714
491
class TestErrorFormatting(TestCase):
715
 
 
 
492
    
716
493
    def test_always_str(self):
717
494
        e = PassThroughError(u'\xb5', 'bar')
718
495
        self.assertIsInstance(e.__str__(), str)
729
506
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
730
507
                lambda x: str(x), e)
731
508
        ## s = str(e)
732
 
        self.assertEqual(s,
 
509
        self.assertEqual(s, 
733
510
                "This class has a docstring but no format string.")
734
511
 
735
512
    def test_mismatched_format_args(self):
739
516
        e = ErrorWithBadFormat(not_thing='x')
740
517
        self.assertStartsWith(
741
518
            str(e), 'Unprintable exception ErrorWithBadFormat')
742
 
 
743
 
    def test_cannot_bind_address(self):
744
 
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
745
 
        e = errors.CannotBindAddress('example.com', 22,
746
 
            socket.error(13, 'Permission denied'))
747
 
        self.assertContainsRe(str(e),
748
 
            r'Cannot bind address "example\.com:22":.*Permission denied')
749
 
 
750
 
    def test_file_timestamp_unavailable(self):            
751
 
        e = errors.FileTimestampUnavailable("/path/foo")
752
 
        self.assertEquals("The filestamp for /path/foo is not available.",
753
 
            str(e))
754
 
            
755
 
    def test_transform_rename_failed(self):
756
 
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
757
 
        self.assertEquals(
758
 
            u"Failed to rename from to to: readonly file",
759
 
            str(e))