← 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-04-09 23:35:55 UTC
  • mfrom: (3316.2.15 api-cleanup)
  • Revision ID: pqm@pqm.ubuntu.com-20080409233555-n26cmi0y1hb98tf6
(robertc) Many VersionedFile api cleanups and deprecations. Some
        incompatible changes included (see NEWS). (Robert Collins)

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 socket
20
 
import sys
21
 
 
22
21
from bzrlib import (
23
22
    bzrdir,
24
23
    errors,
31
30
 
32
31
class TestErrors(TestCaseWithTransport):
33
32
 
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
33
    def test_corrupt_dirstate(self):
42
34
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
43
35
        self.assertEqualDiff(
45
37
            "Error: the reason why",
46
38
            str(error))
47
39
 
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
40
    def test_disabled_method(self):
56
41
        error = errors.DisabledMethod("class name")
57
42
        self.assertEqualDiff(
67
52
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
68
53
            str(error))
69
54
 
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
55
    def test_incompatibleAPI(self):
77
56
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
78
57
        self.assertEqualDiff(
87
66
            "reason: reason for foo",
88
67
            str(error))
89
68
 
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
69
    def test_in_process_transport(self):
97
70
        error = errors.InProcessTransport('fpp')
98
71
        self.assertEqualDiff(
120
93
            "read without data loss.",
121
94
            str(error))
122
95
 
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))
 
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))
128
104
 
129
105
    def test_lock_active(self):
130
106
        error = errors.LockActive("lock description")
161
137
        error = errors.MediumNotConnected("a medium")
162
138
        self.assertEqualDiff(
163
139
            "The medium 'a medium' is not connected.", str(error))
164
 
 
 
140
 
165
141
    def test_no_public_branch(self):
166
142
        b = self.make_branch('.')
167
143
        error = errors.NoPublicBranch(b)
174
150
        error = errors.NoRepositoryPresent(dir)
175
151
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
176
152
        self.assertEqual(-1, str(error).find((dir.transport.base)))
177
 
 
 
153
        
178
154
    def test_no_smart_medium(self):
179
155
        error = errors.NoSmartMedium("a transport")
180
156
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
210
186
            "to be.",
211
187
            str(error))
212
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
 
213
195
    def test_lock_failed(self):
214
196
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
215
197
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
223
205
            "the currently open request.",
224
206
            str(error))
225
207
 
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
208
    def test_unknown_hook(self):
233
209
        error = errors.UnknownHook("branch", "foo")
234
210
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
248
224
            "You will need to upgrade the branch to permit branch stacking.",
249
225
            str(error))
250
226
 
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
227
    def test_unstackable_repository_format(self):
257
228
        format = u'foo'
258
229
        url = "/foo"
264
235
 
265
236
    def test_up_to_date(self):
266
237
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
267
 
        self.assertEqualDiff("The branch format All-in-one "
268
 
                             "format 4 is already at the most "
 
238
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
 
239
                             "format 0.0.4 is already at the most "
269
240
                             "recent format.",
270
241
                             str(error))
271
242
 
399
370
            host='ahost', port=444, msg='Unable to connect to ssh host',
400
371
            orig_error='my_error')
401
372
 
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
373
    def test_malformed_bug_identifier(self):
412
374
        """Test the formatting of MalformedBugIdentifier."""
413
375
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
414
376
        self.assertEqual(
415
 
            'Did not understand bug identifier bogus: reason for bogosity. '
416
 
            'See "bzr help bugs" for more information on this feature.',
 
377
            "Did not understand bug identifier bogus: reason for bogosity",
417
378
            str(error))
418
379
 
419
380
    def test_unknown_bug_tracker_abbreviation(self):
470
431
        self.assertEqual(
471
432
            "Container has multiple records with the same name: n\xc3\xa5me",
472
433
            str(e))
473
 
 
 
434
        
474
435
    def test_check_error(self):
475
436
        # This has a member called 'message', which is problematic in
476
437
        # python2.5 because that is a slot on the base Exception class
532
493
        err = errors.UnknownFormatError('bar', kind='foo')
533
494
        self.assertEquals("Unknown foo format: 'bar'", str(err))
534
495
 
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
496
 
659
497
class PassThroughError(errors.BzrError):
660
 
 
 
498
    
661
499
    _fmt = """Pass through %(foo)s and %(bar)s"""
662
500
 
663
501
    def __init__(self, foo, bar):
670
508
 
671
509
 
672
510
class ErrorWithNoFormat(errors.BzrError):
673
 
    __doc__ = """This class has a docstring but no format string."""
 
511
    """This class has a docstring but no format string."""
674
512
 
675
513
 
676
514
class TestErrorFormatting(TestCase):
677
 
 
 
515
    
678
516
    def test_always_str(self):
679
517
        e = PassThroughError(u'\xb5', 'bar')
680
518
        self.assertIsInstance(e.__str__(), str)
691
529
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
692
530
                lambda x: str(x), e)
693
531
        ## s = str(e)
694
 
        self.assertEqual(s,
 
532
        self.assertEqual(s, 
695
533
                "This class has a docstring but no format string.")
696
534
 
697
535
    def test_mismatched_format_args(self):
701
539
        e = ErrorWithBadFormat(not_thing='x')
702
540
        self.assertStartsWith(
703
541
            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))