← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

Merge bzr.dev and tree-file-ids-as-tuples.

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-2011 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,
25
27
    osutils,
26
 
    symbol_versioning,
27
28
    urlutils,
28
29
    )
29
 
from bzrlib.tests import TestCase, TestCaseWithTransport
 
30
from bzrlib.tests import (
 
31
    TestCase,
 
32
    TestCaseWithTransport,
 
33
    TestSkipped,
 
34
    )
30
35
 
31
36
 
32
37
class TestErrors(TestCaseWithTransport):
33
38
 
 
39
    def test_no_arg_named_message(self):
 
40
        """Ensure the __init__ and _fmt in errors do not have "message" arg.
 
41
 
 
42
        This test fails if __init__ or _fmt in errors has an argument
 
43
        named "message" as this can cause errors in some Python versions.
 
44
        Python 2.5 uses a slot for StandardError.message.
 
45
        See bug #603461
 
46
        """
 
47
        fmt_pattern = re.compile("%\(message\)[sir]")
 
48
        subclasses_present = getattr(errors.BzrError, '__subclasses__', None)
 
49
        if not subclasses_present:
 
50
            raise TestSkipped('__subclasses__ attribute required for classes. '
 
51
                'Requires Python 2.5 or later.')
 
52
        for c in errors.BzrError.__subclasses__():
 
53
            init = getattr(c, '__init__', None)
 
54
            fmt = getattr(c, '_fmt', None)
 
55
            if init:
 
56
                args = inspect.getargspec(init)[0]
 
57
                self.assertFalse('message' in args,
 
58
                    ('Argument name "message" not allowed for '
 
59
                    '"errors.%s.__init__"' % c.__name__))
 
60
            if fmt and fmt_pattern.search(fmt):
 
61
                self.assertFalse(True, ('"message" not allowed in '
 
62
                    '"errors.%s._fmt"' % c.__name__))
 
63
 
34
64
    def test_bad_filename_encoding(self):
35
65
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
36
66
        self.assertEqualDiff(
87
117
            "reason: reason for foo",
88
118
            str(error))
89
119
 
 
120
    def test_inconsistent_delta_delta(self):
 
121
        error = errors.InconsistentDeltaDelta([], 'reason')
 
122
        self.assertEqualDiff(
 
123
            "An inconsistent delta was supplied: []\nreason: reason",
 
124
            str(error))
 
125
 
90
126
    def test_in_process_transport(self):
91
127
        error = errors.InProcessTransport('fpp')
92
128
        self.assertEqualDiff(
114
150
            "read without data loss.",
115
151
            str(error))
116
152
 
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))
 
153
    def test_jail_break(self):
 
154
        error = errors.JailBreak("some url")
 
155
        self.assertEqualDiff("An attempt to access a url outside the server"
 
156
            " jail was made: 'some url'.",
 
157
            str(error))
125
158
 
126
159
    def test_lock_active(self):
127
160
        error = errors.LockActive("lock description")
129
162
            "cannot be broken.",
130
163
            str(error))
131
164
 
 
165
    def test_lock_corrupt(self):
 
166
        error = errors.LockCorrupt("corruption info")
 
167
        self.assertEqualDiff("Lock is apparently held, but corrupted: "
 
168
            "corruption info\n"
 
169
            "Use 'bzr break-lock' to clear it",
 
170
            str(error))
 
171
 
132
172
    def test_knit_data_stream_incompatible(self):
133
173
        error = errors.KnitDataStreamIncompatible(
134
174
            'stream format', 'target format')
158
198
        error = errors.MediumNotConnected("a medium")
159
199
        self.assertEqualDiff(
160
200
            "The medium 'a medium' is not connected.", str(error))
161
 
 
 
201
 
162
202
    def test_no_public_branch(self):
163
203
        b = self.make_branch('.')
164
204
        error = errors.NoPublicBranch(b)
171
211
        error = errors.NoRepositoryPresent(dir)
172
212
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
173
213
        self.assertEqual(-1, str(error).find((dir.transport.base)))
174
 
        
 
214
 
175
215
    def test_no_smart_medium(self):
176
216
        error = errors.NoSmartMedium("a transport")
177
217
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
245
285
            "You will need to upgrade the branch to permit branch stacking.",
246
286
            str(error))
247
287
 
 
288
    def test_unstackable_location(self):
 
289
        error = errors.UnstackableLocationError('foo', 'bar')
 
290
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
 
291
            str(error))
 
292
 
248
293
    def test_unstackable_repository_format(self):
249
294
        format = u'foo'
250
295
        url = "/foo"
255
300
            str(error))
256
301
 
257
302
    def test_up_to_date(self):
258
 
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
259
 
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
260
 
                             "format 0.0.4 is already at the most "
261
 
                             "recent format.",
262
 
                             str(error))
 
303
        error = errors.UpToDateFormat("someformat")
 
304
        self.assertEqualDiff(
 
305
            "The branch format someformat is already at the most "
 
306
            "recent format.", str(error))
263
307
 
264
308
    def test_corrupt_repository(self):
265
309
        repo = self.make_repository('.')
305
349
        self.assertEqual("The value 'foo' is not a valid value.",
306
350
            str(error))
307
351
 
308
 
    def test_bzrnewerror_is_deprecated(self):
309
 
        class DeprecatedError(errors.BzrNewError):
310
 
            pass
311
 
        self.callDeprecated(['BzrNewError was deprecated in bzr 0.13; '
312
 
             'please convert DeprecatedError to use BzrError instead'],
313
 
            DeprecatedError)
314
 
 
315
352
    def test_bzrerror_from_literal_string(self):
316
353
        # Some code constructs BzrError from a literal string, in which case
317
354
        # no further formatting is done.  (I'm not sure raising the base class
404
441
        """Test the formatting of MalformedBugIdentifier."""
405
442
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
406
443
        self.assertEqual(
407
 
            "Did not understand bug identifier bogus: reason for bogosity",
 
444
            'Did not understand bug identifier bogus: reason for bogosity. '
 
445
            'See "bzr help bugs" for more information on this feature.',
408
446
            str(error))
409
447
 
410
448
    def test_unknown_bug_tracker_abbreviation(self):
461
499
        self.assertEqual(
462
500
            "Container has multiple records with the same name: n\xc3\xa5me",
463
501
            str(e))
464
 
        
 
502
 
465
503
    def test_check_error(self):
466
504
        # This has a member called 'message', which is problematic in
467
505
        # python2.5 because that is a slot on the base Exception class
527
565
        err = errors.UnknownRules(['foo', 'bar'])
528
566
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
529
567
 
530
 
    def test_hook_failed(self):
531
 
        # Create an exc_info tuple by raising and catching an exception.
532
 
        try:
533
 
            1/0
534
 
        except ZeroDivisionError:
535
 
            exc_info = sys.exc_info()
536
 
        err = errors.HookFailed('hook stage', 'hook name', exc_info)
537
 
        self.assertStartsWith(
538
 
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
539
 
        self.assertEndsWith(
540
 
            str(err), 'integer division or modulo by zero')
541
 
 
542
568
    def test_tip_change_rejected(self):
543
569
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
544
570
        self.assertEquals(
561
587
        self.assertEquals(
562
588
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
563
589
 
 
590
    def test_smart_message_handler_error(self):
 
591
        # Make an exc_info tuple.
 
592
        try:
 
593
            raise Exception("example error")
 
594
        except Exception:
 
595
            err = errors.SmartMessageHandlerError(sys.exc_info())
 
596
        # GZ 2010-11-08: Should not store exc_info in exception instances.
 
597
        try:
 
598
            self.assertStartsWith(
 
599
                str(err), "The message handler raised an exception:\n")
 
600
            self.assertEndsWith(str(err), "Exception: example error\n")
 
601
        finally:
 
602
            del err
 
603
 
 
604
    def test_must_have_working_tree(self):
 
605
        err = errors.MustHaveWorkingTree('foo', 'bar')
 
606
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
 
607
                                   " working tree.")
 
608
 
 
609
    def test_no_such_view(self):
 
610
        err = errors.NoSuchView('foo')
 
611
        self.assertEquals("No such view: foo.", str(err))
 
612
 
 
613
    def test_views_not_supported(self):
 
614
        err = errors.ViewsNotSupported('atree')
 
615
        err_str = str(err)
 
616
        self.assertStartsWith(err_str, "Views are not supported by ")
 
617
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
 
618
            "tree to a later format.")
 
619
 
 
620
    def test_file_outside_view(self):
 
621
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
 
622
        self.assertEquals('Specified file "baz" is outside the current view: '
 
623
            'foo, bar', str(err))
 
624
 
 
625
    def test_invalid_shelf_id(self):
 
626
        invalid_id = "foo"
 
627
        err = errors.InvalidShelfId(invalid_id)
 
628
        self.assertEqual('"foo" is not a valid shelf id, '
 
629
            'try a number instead.', str(err))
 
630
 
 
631
    def test_unresumable_write_group(self):
 
632
        repo = "dummy repo"
 
633
        wg_tokens = ['token']
 
634
        reason = "a reason"
 
635
        err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
 
636
        self.assertEqual(
 
637
            "Repository dummy repo cannot resume write group "
 
638
            "['token']: a reason", str(err))
 
639
 
 
640
    def test_unsuspendable_write_group(self):
 
641
        repo = "dummy repo"
 
642
        err = errors.UnsuspendableWriteGroup(repo)
 
643
        self.assertEqual(
 
644
            'Repository dummy repo cannot suspend a write group.', str(err))
 
645
 
 
646
    def test_not_branch_no_args(self):
 
647
        err = errors.NotBranchError('path')
 
648
        self.assertEqual('Not a branch: "path".', str(err))
 
649
 
 
650
    def test_not_branch_bzrdir_with_repo(self):
 
651
        bzrdir = self.make_repository('repo').bzrdir
 
652
        err = errors.NotBranchError('path', bzrdir=bzrdir)
 
653
        self.assertEqual(
 
654
            'Not a branch: "path": location is a repository.', str(err))
 
655
 
 
656
    def test_not_branch_bzrdir_without_repo(self):
 
657
        bzrdir = self.make_bzrdir('bzrdir')
 
658
        err = errors.NotBranchError('path', bzrdir=bzrdir)
 
659
        self.assertEqual('Not a branch: "path".', str(err))
 
660
 
 
661
    def test_not_branch_bzrdir_with_recursive_not_branch_error(self):
 
662
        class FakeBzrDir(object):
 
663
            def open_repository(self):
 
664
                # str() on the NotBranchError will trigger a call to this,
 
665
                # which in turn will another, identical NotBranchError.
 
666
                raise errors.NotBranchError('path', bzrdir=FakeBzrDir())
 
667
        err = errors.NotBranchError('path', bzrdir=FakeBzrDir())
 
668
        self.assertEqual('Not a branch: "path".', str(err))
 
669
 
 
670
    def test_not_branch_laziness(self):
 
671
        real_bzrdir = self.make_bzrdir('path')
 
672
        class FakeBzrDir(object):
 
673
            def __init__(self):
 
674
                self.calls = []
 
675
            def open_repository(self):
 
676
                self.calls.append('open_repository')
 
677
                raise errors.NoRepositoryPresent(real_bzrdir)
 
678
        fake_bzrdir = FakeBzrDir()
 
679
        err = errors.NotBranchError('path', bzrdir=fake_bzrdir)
 
680
        self.assertEqual([], fake_bzrdir.calls)
 
681
        str(err)
 
682
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
683
        # Stringifying twice doesn't try to open a repository twice.
 
684
        str(err)
 
685
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
686
 
 
687
    def test_invalid_pattern(self):
 
688
        error = errors.InvalidPattern('Bad pattern msg.')
 
689
        self.assertEqualDiff("Invalid pattern(s) found. Bad pattern msg.",
 
690
            str(error))
 
691
 
 
692
    def test_recursive_bind(self):
 
693
        error = errors.RecursiveBind('foo_bar_branch')
 
694
        msg = ('Branch "foo_bar_branch" appears to be bound to itself. '
 
695
            'Please use `bzr unbind` to fix.')
 
696
        self.assertEqualDiff(msg, str(error))
 
697
 
 
698
    def test_retry_with_new_packs(self):
 
699
        fake_exc_info = ('{exc type}', '{exc value}', '{exc traceback}')
 
700
        error = errors.RetryWithNewPacks(
 
701
            '{context}', reload_occurred=False, exc_info=fake_exc_info)
 
702
        self.assertEqual(
 
703
            'Pack files have changed, reload and retry. context: '
 
704
            '{context} {exc value}', str(error))
 
705
 
564
706
 
565
707
class PassThroughError(errors.BzrError):
566
 
    
 
708
 
567
709
    _fmt = """Pass through %(foo)s and %(bar)s"""
568
710
 
569
711
    def __init__(self, foo, bar):
576
718
 
577
719
 
578
720
class ErrorWithNoFormat(errors.BzrError):
579
 
    """This class has a docstring but no format string."""
 
721
    __doc__ = """This class has a docstring but no format string."""
580
722
 
581
723
 
582
724
class TestErrorFormatting(TestCase):
583
 
    
 
725
 
584
726
    def test_always_str(self):
585
727
        e = PassThroughError(u'\xb5', 'bar')
586
728
        self.assertIsInstance(e.__str__(), str)
593
735
 
594
736
    def test_missing_format_string(self):
595
737
        e = ErrorWithNoFormat(param='randomvalue')
596
 
        s = self.callDeprecated(
597
 
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
598
 
                lambda x: str(x), e)
599
 
        ## s = str(e)
600
 
        self.assertEqual(s, 
601
 
                "This class has a docstring but no format string.")
 
738
        self.assertStartsWith(str(e),
 
739
            "Unprintable exception ErrorWithNoFormat")
602
740
 
603
741
    def test_mismatched_format_args(self):
604
742
        # Even though ErrorWithBadFormat's format string does not match the
607
745
        e = ErrorWithBadFormat(not_thing='x')
608
746
        self.assertStartsWith(
609
747
            str(e), 'Unprintable exception ErrorWithBadFormat')
 
748
 
 
749
    def test_cannot_bind_address(self):
 
750
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
 
751
        e = errors.CannotBindAddress('example.com', 22,
 
752
            socket.error(13, 'Permission denied'))
 
753
        self.assertContainsRe(str(e),
 
754
            r'Cannot bind address "example\.com:22":.*Permission denied')
 
755
 
 
756
    def test_file_timestamp_unavailable(self):            
 
757
        e = errors.FileTimestampUnavailable("/path/foo")
 
758
        self.assertEquals("The filestamp for /path/foo is not available.",
 
759
            str(e))
 
760
            
 
761
    def test_transform_rename_failed(self):
 
762
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
 
763
        self.assertEquals(
 
764
            u"Failed to rename from to to: readonly file",
 
765
            str(e))