← 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: 2008-05-01 11:25:12 UTC
  • mfrom: (3211.7.10 protocol-v3-doc)
  • Revision ID: pqm@pqm.ubuntu.com-20080501112512-b9lgs4w8r43evtn1
Add the smart protocol v3 specification to network-protocol.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006-2011 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
 
    controldir,
 
22
    bzrdir,
26
23
    errors,
27
24
    osutils,
 
25
    symbol_versioning,
28
26
    urlutils,
29
27
    )
30
 
from bzrlib.tests import (
31
 
    TestCase,
32
 
    TestCaseWithTransport,
33
 
    TestSkipped,
34
 
    )
 
28
from bzrlib.tests import TestCase, TestCaseWithTransport
35
29
 
36
30
 
37
31
class TestErrors(TestCaseWithTransport):
38
32
 
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
 
 
64
 
    def test_bad_filename_encoding(self):
65
 
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
66
 
        self.assertEqualDiff(
67
 
            "Filename 'bad/filen\\xe5me' is not valid in your current"
68
 
            " filesystem encoding UTF-8",
69
 
            str(error))
70
 
 
71
33
    def test_corrupt_dirstate(self):
72
34
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
73
35
        self.assertEqualDiff(
75
37
            "Error: the reason why",
76
38
            str(error))
77
39
 
78
 
    def test_dirstate_corrupt(self):
79
 
        error = errors.DirstateCorrupt('.bzr/checkout/dirstate',
80
 
                                       'trailing garbage: "x"')
81
 
        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
82
 
            " appears to be corrupt: trailing garbage: \"x\"",
83
 
            str(error))
84
 
 
85
40
    def test_disabled_method(self):
86
41
        error = errors.DisabledMethod("class name")
87
42
        self.assertEqualDiff(
97
52
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
98
53
            str(error))
99
54
 
100
 
    def test_ghost_revisions_have_no_revno(self):
101
 
        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
102
 
        self.assertEqualDiff("Could not determine revno for {target} because"
103
 
                             " its ancestry shows a ghost at {ghost_rev}",
104
 
                             str(error))
105
 
 
106
55
    def test_incompatibleAPI(self):
107
56
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
108
57
        self.assertEqualDiff(
117
66
            "reason: reason for foo",
118
67
            str(error))
119
68
 
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
 
 
126
69
    def test_in_process_transport(self):
127
70
        error = errors.InProcessTransport('fpp')
128
71
        self.assertEqualDiff(
150
93
            "read without data loss.",
151
94
            str(error))
152
95
 
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))
 
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))
158
104
 
159
105
    def test_lock_active(self):
160
106
        error = errors.LockActive("lock description")
162
108
            "cannot be broken.",
163
109
            str(error))
164
110
 
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
 
 
172
111
    def test_knit_data_stream_incompatible(self):
173
112
        error = errors.KnitDataStreamIncompatible(
174
113
            'stream format', 'target format')
198
137
        error = errors.MediumNotConnected("a medium")
199
138
        self.assertEqualDiff(
200
139
            "The medium 'a medium' is not connected.", str(error))
201
 
 
 
140
 
202
141
    def test_no_public_branch(self):
203
142
        b = self.make_branch('.')
204
143
        error = errors.NoPublicBranch(b)
207
146
            'There is no public branch set for "%s".' % url, str(error))
208
147
 
209
148
    def test_no_repo(self):
210
 
        dir = controldir.ControlDir.create(self.get_url())
 
149
        dir = bzrdir.BzrDir.create(self.get_url())
211
150
        error = errors.NoRepositoryPresent(dir)
212
151
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
213
152
        self.assertEqual(-1, str(error).find((dir.transport.base)))
214
 
 
 
153
        
215
154
    def test_no_smart_medium(self):
216
155
        error = errors.NoSmartMedium("a transport")
217
156
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
247
186
            "to be.",
248
187
            str(error))
249
188
 
 
189
    def test_read_only_lock_error(self):
 
190
        error = self.applyDeprecated(symbol_versioning.zero_ninetytwo,
 
191
            errors.ReadOnlyLockError, 'filename', 'error message')
 
192
        self.assertEqualDiff("Cannot acquire write lock on filename."
 
193
                             " error message", str(error))
 
194
 
250
195
    def test_lock_failed(self):
251
196
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
252
197
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
260
205
            "the currently open request.",
261
206
            str(error))
262
207
 
263
 
    def test_unavailable_representation(self):
264
 
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
265
 
        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
266
 
            "('key',) which is encoded as 'fulltext'.",
267
 
            str(error))
268
 
 
269
208
    def test_unknown_hook(self):
270
209
        error = errors.UnknownHook("branch", "foo")
271
210
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
285
224
            "You will need to upgrade the branch to permit branch stacking.",
286
225
            str(error))
287
226
 
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
 
 
293
227
    def test_unstackable_repository_format(self):
294
228
        format = u'foo'
295
229
        url = "/foo"
300
234
            str(error))
301
235
 
302
236
    def test_up_to_date(self):
303
 
        error = errors.UpToDateFormat("someformat")
304
 
        self.assertEqualDiff(
305
 
            "The branch format someformat is already at the most "
306
 
            "recent format.", str(error))
 
237
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
 
238
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
 
239
                             "format 0.0.4 is already at the most "
 
240
                             "recent format.",
 
241
                             str(error))
307
242
 
308
243
    def test_corrupt_repository(self):
309
244
        repo = self.make_repository('.')
349
284
        self.assertEqual("The value 'foo' is not a valid value.",
350
285
            str(error))
351
286
 
 
287
    def test_bzrnewerror_is_deprecated(self):
 
288
        class DeprecatedError(errors.BzrNewError):
 
289
            pass
 
290
        self.callDeprecated(['BzrNewError was deprecated in bzr 0.13; '
 
291
             'please convert DeprecatedError to use BzrError instead'],
 
292
            DeprecatedError)
 
293
 
352
294
    def test_bzrerror_from_literal_string(self):
353
295
        # Some code constructs BzrError from a literal string, in which case
354
296
        # no further formatting is done.  (I'm not sure raising the base class
428
370
            host='ahost', port=444, msg='Unable to connect to ssh host',
429
371
            orig_error='my_error')
430
372
 
431
 
    def test_target_not_branch(self):
432
 
        """Test the formatting of TargetNotBranch."""
433
 
        error = errors.TargetNotBranch('foo')
434
 
        self.assertEqual(
435
 
            "Your branch does not have all of the revisions required in "
436
 
            "order to merge this merge directive and the target "
437
 
            "location specified in the merge directive is not a branch: "
438
 
            "foo.", str(error))
439
 
 
440
373
    def test_malformed_bug_identifier(self):
441
374
        """Test the formatting of MalformedBugIdentifier."""
442
375
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
443
376
        self.assertEqual(
444
 
            'Did not understand bug identifier bogus: reason for bogosity. '
445
 
            'See "bzr help bugs" for more information on this feature.',
 
377
            "Did not understand bug identifier bogus: reason for bogosity",
446
378
            str(error))
447
379
 
448
380
    def test_unknown_bug_tracker_abbreviation(self):
499
431
        self.assertEqual(
500
432
            "Container has multiple records with the same name: n\xc3\xa5me",
501
433
            str(e))
502
 
 
 
434
        
503
435
    def test_check_error(self):
504
436
        # This has a member called 'message', which is problematic in
505
437
        # python2.5 because that is a slot on the base Exception class
561
493
        err = errors.UnknownFormatError('bar', kind='foo')
562
494
        self.assertEquals("Unknown foo format: 'bar'", str(err))
563
495
 
564
 
    def test_unknown_rules(self):
565
 
        err = errors.UnknownRules(['foo', 'bar'])
566
 
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
567
 
 
568
 
    def test_tip_change_rejected(self):
569
 
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
570
 
        self.assertEquals(
571
 
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
572
 
            unicode(err))
573
 
        self.assertEquals(
574
 
            'Tip change rejected: Unicode message\xe2\x80\xbd',
575
 
            str(err))
576
 
 
577
 
    def test_error_from_smart_server(self):
578
 
        error_tuple = ('error', 'tuple')
579
 
        err = errors.ErrorFromSmartServer(error_tuple)
580
 
        self.assertEquals(
581
 
            "Error received from smart server: ('error', 'tuple')", str(err))
582
 
 
583
 
    def test_untranslateable_error_from_smart_server(self):
584
 
        error_tuple = ('error', 'tuple')
585
 
        orig_err = errors.ErrorFromSmartServer(error_tuple)
586
 
        err = errors.UnknownErrorFromSmartServer(orig_err)
587
 
        self.assertEquals(
588
 
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
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
 
 
706
496
 
707
497
class PassThroughError(errors.BzrError):
708
 
 
 
498
    
709
499
    _fmt = """Pass through %(foo)s and %(bar)s"""
710
500
 
711
501
    def __init__(self, foo, bar):
718
508
 
719
509
 
720
510
class ErrorWithNoFormat(errors.BzrError):
721
 
    __doc__ = """This class has a docstring but no format string."""
 
511
    """This class has a docstring but no format string."""
722
512
 
723
513
 
724
514
class TestErrorFormatting(TestCase):
725
 
 
 
515
    
726
516
    def test_always_str(self):
727
517
        e = PassThroughError(u'\xb5', 'bar')
728
518
        self.assertIsInstance(e.__str__(), str)
735
525
 
736
526
    def test_missing_format_string(self):
737
527
        e = ErrorWithNoFormat(param='randomvalue')
738
 
        self.assertStartsWith(str(e),
739
 
            "Unprintable exception ErrorWithNoFormat")
 
528
        s = self.callDeprecated(
 
529
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
 
530
                lambda x: str(x), e)
 
531
        ## s = str(e)
 
532
        self.assertEqual(s, 
 
533
                "This class has a docstring but no format string.")
740
534
 
741
535
    def test_mismatched_format_args(self):
742
536
        # Even though ErrorWithBadFormat's format string does not match the
745
539
        e = ErrorWithBadFormat(not_thing='x')
746
540
        self.assertStartsWith(
747
541
            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))