← 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: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
3
 
#            and others
 
1
# Copyright (C) 2006-2010 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
14
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
16
 
19
17
"""Tests for the formatting and construction of errors."""
20
18
 
 
19
import inspect
 
20
import re
 
21
import socket
21
22
import sys
 
23
 
22
24
from bzrlib import (
23
25
    bzrdir,
24
26
    errors,
26
28
    symbol_versioning,
27
29
    urlutils,
28
30
    )
29
 
from bzrlib.tests import TestCase, TestCaseWithTransport
 
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
30
32
 
31
33
 
32
34
class TestErrors(TestCaseWithTransport):
33
35
 
 
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
 
34
61
    def test_bad_filename_encoding(self):
35
62
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
36
63
        self.assertEqualDiff(
87
114
            "reason: reason for foo",
88
115
            str(error))
89
116
 
 
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
 
90
123
    def test_in_process_transport(self):
91
124
        error = errors.InProcessTransport('fpp')
92
125
        self.assertEqualDiff(
114
147
            "read without data loss.",
115
148
            str(error))
116
149
 
117
 
    def test_install_failed(self):
118
 
        error = errors.InstallFailed(['rev-one'])
119
 
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
120
 
        error = errors.InstallFailed(['rev-one', 'rev-two'])
121
 
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
122
 
                         str(error))
123
 
        error = errors.InstallFailed([None])
124
 
        self.assertEqual("Could not install revisions:\nNone", str(error))
 
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))
125
155
 
126
156
    def test_lock_active(self):
127
157
        error = errors.LockActive("lock description")
158
188
        error = errors.MediumNotConnected("a medium")
159
189
        self.assertEqualDiff(
160
190
            "The medium 'a medium' is not connected.", str(error))
161
 
 
 
191
 
162
192
    def test_no_public_branch(self):
163
193
        b = self.make_branch('.')
164
194
        error = errors.NoPublicBranch(b)
171
201
        error = errors.NoRepositoryPresent(dir)
172
202
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
173
203
        self.assertEqual(-1, str(error).find((dir.transport.base)))
174
 
        
 
204
 
175
205
    def test_no_smart_medium(self):
176
206
        error = errors.NoSmartMedium("a transport")
177
207
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
245
275
            "You will need to upgrade the branch to permit branch stacking.",
246
276
            str(error))
247
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
 
248
283
    def test_unstackable_repository_format(self):
249
284
        format = u'foo'
250
285
        url = "/foo"
256
291
 
257
292
    def test_up_to_date(self):
258
293
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
259
 
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
260
 
                             "format 0.0.4 is already at the most "
 
294
        self.assertEqualDiff("The branch format All-in-one "
 
295
                             "format 4 is already at the most "
261
296
                             "recent format.",
262
297
                             str(error))
263
298
 
404
439
        """Test the formatting of MalformedBugIdentifier."""
405
440
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
406
441
        self.assertEqual(
407
 
            "Did not understand bug identifier bogus: reason for bogosity",
 
442
            'Did not understand bug identifier bogus: reason for bogosity. '
 
443
            'See "bzr help bugs" for more information on this feature.',
408
444
            str(error))
409
445
 
410
446
    def test_unknown_bug_tracker_abbreviation(self):
461
497
        self.assertEqual(
462
498
            "Container has multiple records with the same name: n\xc3\xa5me",
463
499
            str(e))
464
 
        
 
500
 
465
501
    def test_check_error(self):
466
502
        # This has a member called 'message', which is problematic in
467
503
        # python2.5 because that is a slot on the base Exception class
533
569
            1/0
534
570
        except ZeroDivisionError:
535
571
            exc_info = sys.exc_info()
536
 
        err = errors.HookFailed('hook stage', 'hook name', exc_info)
 
572
        err = errors.HookFailed('hook stage', 'hook name', exc_info, warn=False)
537
573
        self.assertStartsWith(
538
574
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
539
575
        self.assertEndsWith(
560
596
        err = errors.UnknownErrorFromSmartServer(orig_err)
561
597
        self.assertEquals(
562
598
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
563
 
    
 
599
 
564
600
    def test_smart_message_handler_error(self):
565
601
        # Make an exc_info tuple.
566
602
        try:
577
613
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
578
614
                                   " working tree.")
579
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
 
580
632
    def test_invalid_shelf_id(self):
581
633
        invalid_id = "foo"
582
634
        err = errors.InvalidShelfId(invalid_id)
583
635
        self.assertEqual('"foo" is not a valid shelf id, '
584
636
            'try a number instead.', str(err))
585
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
 
586
696
 
587
697
class PassThroughError(errors.BzrError):
588
 
    
 
698
 
589
699
    _fmt = """Pass through %(foo)s and %(bar)s"""
590
700
 
591
701
    def __init__(self, foo, bar):
598
708
 
599
709
 
600
710
class ErrorWithNoFormat(errors.BzrError):
601
 
    """This class has a docstring but no format string."""
 
711
    __doc__ = """This class has a docstring but no format string."""
602
712
 
603
713
 
604
714
class TestErrorFormatting(TestCase):
605
 
    
 
715
 
606
716
    def test_always_str(self):
607
717
        e = PassThroughError(u'\xb5', 'bar')
608
718
        self.assertIsInstance(e.__str__(), str)
619
729
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
620
730
                lambda x: str(x), e)
621
731
        ## s = str(e)
622
 
        self.assertEqual(s, 
 
732
        self.assertEqual(s,
623
733
                "This class has a docstring but no format string.")
624
734
 
625
735
    def test_mismatched_format_args(self):
629
739
        e = ErrorWithBadFormat(not_thing='x')
630
740
        self.assertStartsWith(
631
741
            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))