← 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: Ian Clatworthy
  • Date: 2007-08-13 14:33:10 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070813143310-twhj4la0qnupvze8
Added Quick Start Summary

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 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,
27
 
    osutils,
28
 
    urlutils,
29
 
    )
30
 
from bzrlib.tests import (
31
 
    TestCase,
32
 
    TestCaseWithTransport,
33
 
    TestSkipped,
34
 
    )
 
24
    )
 
25
from bzrlib.tests import TestCase, TestCaseWithTransport
 
26
 
 
27
 
 
28
# TODO: Make sure builtin exception class formats are consistent - e.g. should
 
29
# or shouldn't end with a full stop, etc.
35
30
 
36
31
 
37
32
class TestErrors(TestCaseWithTransport):
38
33
 
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
 
    def test_corrupt_dirstate(self):
72
 
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
73
 
        self.assertEqualDiff(
74
 
            "Inconsistency in dirstate file path/to/dirstate.\n"
75
 
            "Error: the reason why",
76
 
            str(error))
77
 
 
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
34
    def test_disabled_method(self):
86
35
        error = errors.DisabledMethod("class name")
87
36
        self.assertEqualDiff(
97
46
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
98
47
            str(error))
99
48
 
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
49
    def test_incompatibleAPI(self):
107
50
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
108
51
        self.assertEqualDiff(
110
53
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
111
54
            str(error))
112
55
 
113
 
    def test_inconsistent_delta(self):
114
 
        error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
115
 
        self.assertEqualDiff(
116
 
            "An inconsistent delta was supplied involving 'path', 'file-id'\n"
117
 
            "reason: reason for foo",
118
 
            str(error))
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
 
 
126
56
    def test_in_process_transport(self):
127
57
        error = errors.InProcessTransport('fpp')
128
58
        self.assertEqualDiff(
129
59
            "The transport 'fpp' is only accessible within this process.",
130
60
            str(error))
131
61
 
132
 
    def test_invalid_http_range(self):
133
 
        error = errors.InvalidHttpRange('path',
134
 
                                        'Content-Range: potatoes 0-00/o0oo0',
135
 
                                        'bad range')
136
 
        self.assertEquals("Invalid http range"
137
 
                          " 'Content-Range: potatoes 0-00/o0oo0'"
138
 
                          " for path: bad range",
139
 
                          str(error))
140
 
 
141
 
    def test_invalid_range(self):
142
 
        error = errors.InvalidRange('path', 12, 'bad range')
143
 
        self.assertEquals("Invalid range access in path at 12: bad range",
144
 
                          str(error))
145
 
 
146
62
    def test_inventory_modified(self):
147
63
        error = errors.InventoryModified("a tree to be repred")
148
64
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
150
66
            "read without data loss.",
151
67
            str(error))
152
68
 
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))
 
69
    def test_install_failed(self):
 
70
        error = errors.InstallFailed(['rev-one'])
 
71
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
 
72
        error = errors.InstallFailed(['rev-one', 'rev-two'])
 
73
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
 
74
                         str(error))
 
75
        error = errors.InstallFailed([None])
 
76
        self.assertEqual("Could not install revisions:\nNone", str(error))
158
77
 
159
78
    def test_lock_active(self):
160
79
        error = errors.LockActive("lock description")
162
81
            "cannot be broken.",
163
82
            str(error))
164
83
 
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
 
    def test_knit_data_stream_incompatible(self):
173
 
        error = errors.KnitDataStreamIncompatible(
174
 
            'stream format', 'target format')
175
 
        self.assertEqual('Cannot insert knit data stream of format '
176
 
                         '"stream format" into knit of format '
177
 
                         '"target format".', str(error))
178
 
 
179
 
    def test_knit_data_stream_unknown(self):
180
 
        error = errors.KnitDataStreamUnknown(
181
 
            'stream format')
182
 
        self.assertEqual('Cannot parse knit data stream of format '
183
 
                         '"stream format".', str(error))
184
 
 
185
84
    def test_knit_header_error(self):
186
85
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
187
86
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
188
 
                         " for file \"path/to/file\".", str(error))
 
87
                         " for file path/to/file", str(error))
189
88
 
190
89
    def test_knit_index_unknown_method(self):
191
90
        error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
198
97
        error = errors.MediumNotConnected("a medium")
199
98
        self.assertEqualDiff(
200
99
            "The medium 'a medium' is not connected.", str(error))
201
 
 
202
 
    def test_no_public_branch(self):
203
 
        b = self.make_branch('.')
204
 
        error = errors.NoPublicBranch(b)
205
 
        url = urlutils.unescape_for_display(b.base, 'ascii')
206
 
        self.assertEqualDiff(
207
 
            'There is no public branch set for "%s".' % url, str(error))
208
 
 
 
100
        
209
101
    def test_no_repo(self):
210
102
        dir = bzrdir.BzrDir.create(self.get_url())
211
103
        error = errors.NoRepositoryPresent(dir)
212
104
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
213
105
        self.assertEqual(-1, str(error).find((dir.transport.base)))
214
 
 
 
106
        
215
107
    def test_no_smart_medium(self):
216
108
        error = errors.NoSmartMedium("a transport")
217
109
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
226
118
 
227
119
    def test_no_such_id(self):
228
120
        error = errors.NoSuchId("atree", "anid")
229
 
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
 
121
        self.assertEqualDiff("The file id anid is not present in the tree "
230
122
            "atree.",
231
123
            str(error))
232
124
 
233
125
    def test_no_such_revision_in_tree(self):
234
126
        error = errors.NoSuchRevisionInTree("atree", "anid")
235
 
        self.assertEqualDiff("The revision id {anid} is not present in the"
236
 
                             " tree atree.", str(error))
 
127
        self.assertEqualDiff("The revision id anid is not present in the tree "
 
128
            "atree.",
 
129
            str(error))
237
130
        self.assertIsInstance(error, errors.NoSuchRevision)
238
131
 
239
 
    def test_not_stacked(self):
240
 
        error = errors.NotStacked('a branch')
241
 
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
242
 
            str(error))
243
 
 
244
132
    def test_not_write_locked(self):
245
133
        error = errors.NotWriteLocked('a thing to repr')
246
134
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
247
135
            "to be.",
248
136
            str(error))
249
137
 
250
 
    def test_lock_failed(self):
251
 
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
252
 
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
253
 
            str(error))
254
 
        self.assertFalse(error.internal_error)
 
138
    def test_read_only_lock_error(self):
 
139
        error = errors.ReadOnlyLockError('filename', 'error message')
 
140
        self.assertEqualDiff("Cannot acquire write lock on filename."
 
141
                             " error message", str(error))
255
142
 
256
143
    def test_too_many_concurrent_requests(self):
257
144
        error = errors.TooManyConcurrentRequests("a medium")
260
147
            "the currently open request.",
261
148
            str(error))
262
149
 
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
150
    def test_unknown_hook(self):
270
151
        error = errors.UnknownHook("branch", "foo")
271
152
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
276
157
            " of bzrlib.",
277
158
            str(error))
278
159
 
279
 
    def test_unstackable_branch_format(self):
280
 
        format = u'foo'
281
 
        url = "/foo"
282
 
        error = errors.UnstackableBranchFormat(format, url)
283
 
        self.assertEqualDiff(
284
 
            "The branch '/foo'(foo) is not a stackable format. "
285
 
            "You will need to upgrade the branch to permit branch stacking.",
286
 
            str(error))
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
 
 
293
 
    def test_unstackable_repository_format(self):
294
 
        format = u'foo'
295
 
        url = "/foo"
296
 
        error = errors.UnstackableRepositoryFormat(format, url)
297
 
        self.assertEqualDiff(
298
 
            "The repository '/foo'(foo) is not a stackable format. "
299
 
            "You will need to upgrade the repository to permit branch stacking.",
300
 
            str(error))
301
 
 
302
160
    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))
 
161
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
 
162
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
 
163
                             "format 0.0.4 is already at the most "
 
164
                             "recent format.",
 
165
                             str(error))
307
166
 
308
167
    def test_corrupt_repository(self):
309
168
        repo = self.make_repository('.')
435
294
            host='ahost', port=444, msg='Unable to connect to ssh host',
436
295
            orig_error='my_error')
437
296
 
438
 
    def test_target_not_branch(self):
439
 
        """Test the formatting of TargetNotBranch."""
440
 
        error = errors.TargetNotBranch('foo')
441
 
        self.assertEqual(
442
 
            "Your branch does not have all of the revisions required in "
443
 
            "order to merge this merge directive and the target "
444
 
            "location specified in the merge directive is not a branch: "
445
 
            "foo.", str(error))
446
 
 
447
297
    def test_malformed_bug_identifier(self):
448
298
        """Test the formatting of MalformedBugIdentifier."""
449
299
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
450
300
        self.assertEqual(
451
 
            'Did not understand bug identifier bogus: reason for bogosity. '
452
 
            'See "bzr help bugs" for more information on this feature.',
 
301
            "Did not understand bug identifier bogus: reason for bogosity",
453
302
            str(error))
454
303
 
455
304
    def test_unknown_bug_tracker_abbreviation(self):
504
353
        """Test the formatting of DuplicateRecordNameError."""
505
354
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
506
355
        self.assertEqual(
507
 
            "Container has multiple records with the same name: n\xc3\xa5me",
508
 
            str(e))
509
 
 
510
 
    def test_check_error(self):
511
 
        # This has a member called 'message', which is problematic in
512
 
        # python2.5 because that is a slot on the base Exception class
513
 
        e = errors.BzrCheckError('example check failure')
514
 
        self.assertEqual(
515
 
            "Internal check failed: example check failure",
516
 
            str(e))
517
 
        self.assertTrue(e.internal_error)
518
 
 
519
 
    def test_repository_data_stream_error(self):
520
 
        """Test the formatting of RepositoryDataStreamError."""
521
 
        e = errors.RepositoryDataStreamError(u"my reason")
522
 
        self.assertEqual(
523
 
            "Corrupt or incompatible data stream: my reason", str(e))
524
 
 
525
 
    def test_immortal_pending_deletion_message(self):
526
 
        err = errors.ImmortalPendingDeletion('foo')
527
 
        self.assertEquals(
528
 
            "Unable to delete transform temporary directory foo.  "
529
 
            "Please examine foo to see if it contains any files "
530
 
            "you wish to keep, and delete it when you are done.",
531
 
            str(err))
532
 
 
533
 
    def test_unable_create_symlink(self):
534
 
        err = errors.UnableCreateSymlink()
535
 
        self.assertEquals(
536
 
            "Unable to create symlink on this platform",
537
 
            str(err))
538
 
        err = errors.UnableCreateSymlink(path=u'foo')
539
 
        self.assertEquals(
540
 
            "Unable to create symlink 'foo' on this platform",
541
 
            str(err))
542
 
        err = errors.UnableCreateSymlink(path=u'\xb5')
543
 
        self.assertEquals(
544
 
            "Unable to create symlink u'\\xb5' on this platform",
545
 
            str(err))
546
 
 
547
 
    def test_invalid_url_join(self):
548
 
        """Test the formatting of InvalidURLJoin."""
549
 
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
550
 
        self.assertEqual(
551
 
            "Invalid URL join request: Reason: 'base path' + ('args',)",
552
 
            str(e))
553
 
 
554
 
    def test_incorrect_url(self):
555
 
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
556
 
        self.assertEquals(
557
 
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
558
 
             "http://bug.com/"),
559
 
            str(err))
560
 
 
561
 
    def test_unable_encode_path(self):
562
 
        err = errors.UnableEncodePath('foo', 'executable')
563
 
        self.assertEquals("Unable to encode executable path 'foo' in "
564
 
            "user encoding " + osutils.get_user_encoding(),
565
 
            str(err))
566
 
 
567
 
    def test_unknown_format(self):
568
 
        err = errors.UnknownFormatError('bar', kind='foo')
569
 
        self.assertEquals("Unknown foo format: 'bar'", str(err))
570
 
 
571
 
    def test_unknown_rules(self):
572
 
        err = errors.UnknownRules(['foo', 'bar'])
573
 
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
574
 
 
575
 
    def test_hook_failed(self):
576
 
        # Create an exc_info tuple by raising and catching an exception.
577
 
        try:
578
 
            1/0
579
 
        except ZeroDivisionError:
580
 
            err = errors.HookFailed('hook stage', 'hook name', sys.exc_info(),
581
 
                warn=False)
582
 
        # GZ 2010-11-08: Should not store exc_info in exception instances, but
583
 
        #                HookFailed is deprecated anyway and could maybe go.
584
 
        try:
585
 
            self.assertStartsWith(
586
 
                str(err), 'Hook \'hook name\' during hook stage failed:\n')
587
 
            self.assertEndsWith(
588
 
                str(err), 'integer division or modulo by zero')
589
 
        finally:
590
 
            del err
591
 
 
592
 
    def test_tip_change_rejected(self):
593
 
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
594
 
        self.assertEquals(
595
 
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
596
 
            unicode(err))
597
 
        self.assertEquals(
598
 
            'Tip change rejected: Unicode message\xe2\x80\xbd',
599
 
            str(err))
600
 
 
601
 
    def test_error_from_smart_server(self):
602
 
        error_tuple = ('error', 'tuple')
603
 
        err = errors.ErrorFromSmartServer(error_tuple)
604
 
        self.assertEquals(
605
 
            "Error received from smart server: ('error', 'tuple')", str(err))
606
 
 
607
 
    def test_untranslateable_error_from_smart_server(self):
608
 
        error_tuple = ('error', 'tuple')
609
 
        orig_err = errors.ErrorFromSmartServer(error_tuple)
610
 
        err = errors.UnknownErrorFromSmartServer(orig_err)
611
 
        self.assertEquals(
612
 
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
613
 
 
614
 
    def test_smart_message_handler_error(self):
615
 
        # Make an exc_info tuple.
616
 
        try:
617
 
            raise Exception("example error")
618
 
        except Exception:
619
 
            err = errors.SmartMessageHandlerError(sys.exc_info())
620
 
        # GZ 2010-11-08: Should not store exc_info in exception instances.
621
 
        try:
622
 
            self.assertStartsWith(
623
 
                str(err), "The message handler raised an exception:\n")
624
 
            self.assertEndsWith(str(err), "Exception: example error\n")
625
 
        finally:
626
 
            del err
627
 
 
628
 
    def test_must_have_working_tree(self):
629
 
        err = errors.MustHaveWorkingTree('foo', 'bar')
630
 
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
631
 
                                   " working tree.")
632
 
 
633
 
    def test_no_such_view(self):
634
 
        err = errors.NoSuchView('foo')
635
 
        self.assertEquals("No such view: foo.", str(err))
636
 
 
637
 
    def test_views_not_supported(self):
638
 
        err = errors.ViewsNotSupported('atree')
639
 
        err_str = str(err)
640
 
        self.assertStartsWith(err_str, "Views are not supported by ")
641
 
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
642
 
            "tree to a later format.")
643
 
 
644
 
    def test_file_outside_view(self):
645
 
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
646
 
        self.assertEquals('Specified file "baz" is outside the current view: '
647
 
            'foo, bar', str(err))
648
 
 
649
 
    def test_invalid_shelf_id(self):
650
 
        invalid_id = "foo"
651
 
        err = errors.InvalidShelfId(invalid_id)
652
 
        self.assertEqual('"foo" is not a valid shelf id, '
653
 
            'try a number instead.', str(err))
654
 
 
655
 
    def test_unresumable_write_group(self):
656
 
        repo = "dummy repo"
657
 
        wg_tokens = ['token']
658
 
        reason = "a reason"
659
 
        err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
660
 
        self.assertEqual(
661
 
            "Repository dummy repo cannot resume write group "
662
 
            "['token']: a reason", str(err))
663
 
 
664
 
    def test_unsuspendable_write_group(self):
665
 
        repo = "dummy repo"
666
 
        err = errors.UnsuspendableWriteGroup(repo)
667
 
        self.assertEqual(
668
 
            'Repository dummy repo cannot suspend a write group.', str(err))
669
 
 
670
 
    def test_not_branch_no_args(self):
671
 
        err = errors.NotBranchError('path')
672
 
        self.assertEqual('Not a branch: "path".', str(err))
673
 
 
674
 
    def test_not_branch_bzrdir_with_repo(self):
675
 
        bzrdir = self.make_repository('repo').bzrdir
676
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
677
 
        self.assertEqual(
678
 
            'Not a branch: "path": location is a repository.', str(err))
679
 
 
680
 
    def test_not_branch_bzrdir_without_repo(self):
681
 
        bzrdir = self.make_bzrdir('bzrdir')
682
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
683
 
        self.assertEqual('Not a branch: "path".', str(err))
684
 
 
685
 
    def test_not_branch_bzrdir_with_recursive_not_branch_error(self):
686
 
        class FakeBzrDir(object):
687
 
            def open_repository(self):
688
 
                # str() on the NotBranchError will trigger a call to this,
689
 
                # which in turn will another, identical NotBranchError.
690
 
                raise errors.NotBranchError('path', bzrdir=FakeBzrDir())
691
 
        err = errors.NotBranchError('path', bzrdir=FakeBzrDir())
692
 
        self.assertEqual('Not a branch: "path".', str(err))
693
 
 
694
 
    def test_not_branch_laziness(self):
695
 
        real_bzrdir = self.make_bzrdir('path')
696
 
        class FakeBzrDir(object):
697
 
            def __init__(self):
698
 
                self.calls = []
699
 
            def open_repository(self):
700
 
                self.calls.append('open_repository')
701
 
                raise errors.NoRepositoryPresent(real_bzrdir)
702
 
        fake_bzrdir = FakeBzrDir()
703
 
        err = errors.NotBranchError('path', bzrdir=fake_bzrdir)
704
 
        self.assertEqual([], fake_bzrdir.calls)
705
 
        str(err)
706
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
707
 
        # Stringifying twice doesn't try to open a repository twice.
708
 
        str(err)
709
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
710
 
 
711
 
    def test_invalid_pattern(self):
712
 
        error = errors.InvalidPattern('Bad pattern msg.')
713
 
        self.assertEqualDiff("Invalid pattern(s) found. Bad pattern msg.",
714
 
            str(error))
715
 
 
716
 
    def test_recursive_bind(self):
717
 
        error = errors.RecursiveBind('foo_bar_branch')
718
 
        msg = ('Branch "foo_bar_branch" appears to be bound to itself. '
719
 
            'Please use `bzr unbind` to fix.')
720
 
        self.assertEqualDiff(msg, str(error))
 
356
            "Container has multiple records with the same name: \"n\xc3\xa5me\"",
 
357
            str(e))
721
358
 
722
359
 
723
360
class PassThroughError(errors.BzrError):
724
 
 
 
361
    
725
362
    _fmt = """Pass through %(foo)s and %(bar)s"""
726
363
 
727
364
    def __init__(self, foo, bar):
734
371
 
735
372
 
736
373
class ErrorWithNoFormat(errors.BzrError):
737
 
    __doc__ = """This class has a docstring but no format string."""
 
374
    """This class has a docstring but no format string."""
738
375
 
739
376
 
740
377
class TestErrorFormatting(TestCase):
741
 
 
 
378
    
742
379
    def test_always_str(self):
743
380
        e = PassThroughError(u'\xb5', 'bar')
744
381
        self.assertIsInstance(e.__str__(), str)
755
392
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
756
393
                lambda x: str(x), e)
757
394
        ## s = str(e)
758
 
        self.assertEqual(s,
 
395
        self.assertEqual(s, 
759
396
                "This class has a docstring but no format string.")
760
397
 
761
398
    def test_mismatched_format_args(self):
765
402
        e = ErrorWithBadFormat(not_thing='x')
766
403
        self.assertStartsWith(
767
404
            str(e), 'Unprintable exception ErrorWithBadFormat')
768
 
 
769
 
    def test_cannot_bind_address(self):
770
 
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
771
 
        e = errors.CannotBindAddress('example.com', 22,
772
 
            socket.error(13, 'Permission denied'))
773
 
        self.assertContainsRe(str(e),
774
 
            r'Cannot bind address "example\.com:22":.*Permission denied')
775
 
 
776
 
    def test_file_timestamp_unavailable(self):            
777
 
        e = errors.FileTimestampUnavailable("/path/foo")
778
 
        self.assertEquals("The filestamp for /path/foo is not available.",
779
 
            str(e))
780
 
            
781
 
    def test_transform_rename_failed(self):
782
 
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
783
 
        self.assertEquals(
784
 
            u"Failed to rename from to to: readonly file",
785
 
            str(e))