← 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-10-12 10:43:30 UTC
  • mfrom: (5487.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20101012104330-tsonnndvloj18v4q
(vila) Add a --no-tree option for init and push (Matthew Gordon)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006 Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
 
1
# Copyright (C) 2006-2010 Canonical Ltd
3
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
13
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# 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
17
16
 
18
17
"""Tests for the formatting and construction of errors."""
19
18
 
 
19
import inspect
 
20
import re
 
21
import socket
 
22
import sys
 
23
 
20
24
from bzrlib import (
21
25
    bzrdir,
22
26
    errors,
 
27
    osutils,
 
28
    symbol_versioning,
 
29
    urlutils,
23
30
    )
24
 
from bzrlib.tests import TestCase, TestCaseWithTransport
25
 
 
26
 
 
27
 
# TODO: Make sure builtin exception class formats are consistent - e.g. should
28
 
# or shouldn't end with a full stop, etc.
 
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
29
32
 
30
33
 
31
34
class TestErrors(TestCaseWithTransport):
32
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
 
 
61
    def test_bad_filename_encoding(self):
 
62
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
 
63
        self.assertEqualDiff(
 
64
            "Filename 'bad/filen\\xe5me' is not valid in your current"
 
65
            " filesystem encoding UTF-8",
 
66
            str(error))
 
67
 
 
68
    def test_corrupt_dirstate(self):
 
69
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
 
70
        self.assertEqualDiff(
 
71
            "Inconsistency in dirstate file path/to/dirstate.\n"
 
72
            "Error: the reason why",
 
73
            str(error))
 
74
 
 
75
    def test_dirstate_corrupt(self):
 
76
        error = errors.DirstateCorrupt('.bzr/checkout/dirstate',
 
77
                                       'trailing garbage: "x"')
 
78
        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
 
79
            " appears to be corrupt: trailing garbage: \"x\"",
 
80
            str(error))
 
81
 
33
82
    def test_disabled_method(self):
34
83
        error = errors.DisabledMethod("class name")
35
84
        self.assertEqualDiff(
40
89
        self.assertEqualDiff('File id {a_file_id} already exists in inventory'
41
90
                             ' as foo', str(error))
42
91
 
 
92
    def test_duplicate_help_prefix(self):
 
93
        error = errors.DuplicateHelpPrefix('foo')
 
94
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
 
95
            str(error))
 
96
 
 
97
    def test_ghost_revisions_have_no_revno(self):
 
98
        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
 
99
        self.assertEqualDiff("Could not determine revno for {target} because"
 
100
                             " its ancestry shows a ghost at {ghost_rev}",
 
101
                             str(error))
 
102
 
 
103
    def test_incompatibleAPI(self):
 
104
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
 
105
        self.assertEqualDiff(
 
106
            'The API for "module" is not compatible with "(1, 2, 3)". '
 
107
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
 
108
            str(error))
 
109
 
 
110
    def test_inconsistent_delta(self):
 
111
        error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
 
112
        self.assertEqualDiff(
 
113
            "An inconsistent delta was supplied involving 'path', 'file-id'\n"
 
114
            "reason: reason for foo",
 
115
            str(error))
 
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
 
 
123
    def test_in_process_transport(self):
 
124
        error = errors.InProcessTransport('fpp')
 
125
        self.assertEqualDiff(
 
126
            "The transport 'fpp' is only accessible within this process.",
 
127
            str(error))
 
128
 
 
129
    def test_invalid_http_range(self):
 
130
        error = errors.InvalidHttpRange('path',
 
131
                                        'Content-Range: potatoes 0-00/o0oo0',
 
132
                                        'bad range')
 
133
        self.assertEquals("Invalid http range"
 
134
                          " 'Content-Range: potatoes 0-00/o0oo0'"
 
135
                          " for path: bad range",
 
136
                          str(error))
 
137
 
 
138
    def test_invalid_range(self):
 
139
        error = errors.InvalidRange('path', 12, 'bad range')
 
140
        self.assertEquals("Invalid range access in path at 12: bad range",
 
141
                          str(error))
 
142
 
43
143
    def test_inventory_modified(self):
44
144
        error = errors.InventoryModified("a tree to be repred")
45
145
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
47
147
            "read without data loss.",
48
148
            str(error))
49
149
 
50
 
    def test_install_failed(self):
51
 
        error = errors.InstallFailed(['rev-one'])
52
 
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
53
 
        error = errors.InstallFailed(['rev-one', 'rev-two'])
54
 
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
55
 
                         str(error))
56
 
        error = errors.InstallFailed([None])
57
 
        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))
58
155
 
59
156
    def test_lock_active(self):
60
157
        error = errors.LockActive("lock description")
62
159
            "cannot be broken.",
63
160
            str(error))
64
161
 
 
162
    def test_lock_corrupt(self):
 
163
        error = errors.LockCorrupt("corruption info")
 
164
        self.assertEqualDiff("Lock is apparently held, but corrupted: "
 
165
            "corruption info\n"
 
166
            "Use 'bzr break-lock' to clear it",
 
167
            str(error))
 
168
 
 
169
    def test_knit_data_stream_incompatible(self):
 
170
        error = errors.KnitDataStreamIncompatible(
 
171
            'stream format', 'target format')
 
172
        self.assertEqual('Cannot insert knit data stream of format '
 
173
                         '"stream format" into knit of format '
 
174
                         '"target format".', str(error))
 
175
 
 
176
    def test_knit_data_stream_unknown(self):
 
177
        error = errors.KnitDataStreamUnknown(
 
178
            'stream format')
 
179
        self.assertEqual('Cannot parse knit data stream of format '
 
180
                         '"stream format".', str(error))
 
181
 
65
182
    def test_knit_header_error(self):
66
183
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
67
184
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
68
 
                         " for file path/to/file", str(error))
 
185
                         " for file \"path/to/file\".", str(error))
69
186
 
70
187
    def test_knit_index_unknown_method(self):
71
188
        error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
78
195
        error = errors.MediumNotConnected("a medium")
79
196
        self.assertEqualDiff(
80
197
            "The medium 'a medium' is not connected.", str(error))
81
 
        
 
198
 
 
199
    def test_no_public_branch(self):
 
200
        b = self.make_branch('.')
 
201
        error = errors.NoPublicBranch(b)
 
202
        url = urlutils.unescape_for_display(b.base, 'ascii')
 
203
        self.assertEqualDiff(
 
204
            'There is no public branch set for "%s".' % url, str(error))
 
205
 
82
206
    def test_no_repo(self):
83
207
        dir = bzrdir.BzrDir.create(self.get_url())
84
208
        error = errors.NoRepositoryPresent(dir)
85
209
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
86
210
        self.assertEqual(-1, str(error).find((dir.transport.base)))
87
 
        
 
211
 
88
212
    def test_no_smart_medium(self):
89
213
        error = errors.NoSmartMedium("a transport")
90
214
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
91
215
            "smart protocol.",
92
216
            str(error))
93
217
 
 
218
    def test_no_help_topic(self):
 
219
        error = errors.NoHelpTopic("topic")
 
220
        self.assertEqualDiff("No help could be found for 'topic'. "
 
221
            "Please use 'bzr help topics' to obtain a list of topics.",
 
222
            str(error))
 
223
 
94
224
    def test_no_such_id(self):
95
225
        error = errors.NoSuchId("atree", "anid")
96
 
        self.assertEqualDiff("The file id anid is not present in the tree "
 
226
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
97
227
            "atree.",
98
228
            str(error))
99
229
 
100
230
    def test_no_such_revision_in_tree(self):
101
231
        error = errors.NoSuchRevisionInTree("atree", "anid")
102
 
        self.assertEqualDiff("The revision id anid is not present in the tree "
103
 
            "atree.",
104
 
            str(error))
 
232
        self.assertEqualDiff("The revision id {anid} is not present in the"
 
233
                             " tree atree.", str(error))
105
234
        self.assertIsInstance(error, errors.NoSuchRevision)
106
235
 
 
236
    def test_not_stacked(self):
 
237
        error = errors.NotStacked('a branch')
 
238
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
 
239
            str(error))
 
240
 
107
241
    def test_not_write_locked(self):
108
242
        error = errors.NotWriteLocked('a thing to repr')
109
243
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
110
244
            "to be.",
111
245
            str(error))
112
246
 
113
 
    def test_read_only_lock_error(self):
114
 
        error = errors.ReadOnlyLockError('filename', 'error message')
115
 
        self.assertEqualDiff("Cannot acquire write lock on filename."
116
 
                             " error message", str(error))
 
247
    def test_lock_failed(self):
 
248
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
 
249
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
 
250
            str(error))
 
251
        self.assertFalse(error.internal_error)
117
252
 
118
253
    def test_too_many_concurrent_requests(self):
119
254
        error = errors.TooManyConcurrentRequests("a medium")
120
255
        self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
121
256
            "request limit. Be sure to finish_writing and finish_reading on "
122
 
            "the current request that is open.",
 
257
            "the currently open request.",
 
258
            str(error))
 
259
 
 
260
    def test_unavailable_representation(self):
 
261
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
 
262
        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
 
263
            "('key',) which is encoded as 'fulltext'.",
123
264
            str(error))
124
265
 
125
266
    def test_unknown_hook(self):
132
273
            " of bzrlib.",
133
274
            str(error))
134
275
 
 
276
    def test_unstackable_branch_format(self):
 
277
        format = u'foo'
 
278
        url = "/foo"
 
279
        error = errors.UnstackableBranchFormat(format, url)
 
280
        self.assertEqualDiff(
 
281
            "The branch '/foo'(foo) is not a stackable format. "
 
282
            "You will need to upgrade the branch to permit branch stacking.",
 
283
            str(error))
 
284
 
 
285
    def test_unstackable_location(self):
 
286
        error = errors.UnstackableLocationError('foo', 'bar')
 
287
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
 
288
            str(error))
 
289
 
 
290
    def test_unstackable_repository_format(self):
 
291
        format = u'foo'
 
292
        url = "/foo"
 
293
        error = errors.UnstackableRepositoryFormat(format, url)
 
294
        self.assertEqualDiff(
 
295
            "The repository '/foo'(foo) is not a stackable format. "
 
296
            "You will need to upgrade the repository to permit branch stacking.",
 
297
            str(error))
 
298
 
135
299
    def test_up_to_date(self):
136
300
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
137
 
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
138
 
                             "format 0.0.4 is already at the most "
 
301
        self.assertEqualDiff("The branch format All-in-one "
 
302
                             "format 4 is already at the most "
139
303
                             "recent format.",
140
304
                             str(error))
141
305
 
147
311
                             repo.bzrdir.root_transport.base,
148
312
                             str(error))
149
313
 
 
314
    def test_read_error(self):
 
315
        # a unicode path to check that %r is being used.
 
316
        path = u'a path'
 
317
        error = errors.ReadError(path)
 
318
        self.assertEqualDiff("Error reading from u'a path'.", str(error))
 
319
 
 
320
    def test_bad_index_format_signature(self):
 
321
        error = errors.BadIndexFormatSignature("foo", "bar")
 
322
        self.assertEqual("foo is not an index of type bar.",
 
323
            str(error))
 
324
 
 
325
    def test_bad_index_data(self):
 
326
        error = errors.BadIndexData("foo")
 
327
        self.assertEqual("Error in data for index foo.",
 
328
            str(error))
 
329
 
 
330
    def test_bad_index_duplicate_key(self):
 
331
        error = errors.BadIndexDuplicateKey("foo", "bar")
 
332
        self.assertEqual("The key 'foo' is already in index 'bar'.",
 
333
            str(error))
 
334
 
 
335
    def test_bad_index_key(self):
 
336
        error = errors.BadIndexKey("foo")
 
337
        self.assertEqual("The key 'foo' is not a valid key.",
 
338
            str(error))
 
339
 
 
340
    def test_bad_index_options(self):
 
341
        error = errors.BadIndexOptions("foo")
 
342
        self.assertEqual("Could not parse options for index foo.",
 
343
            str(error))
 
344
 
 
345
    def test_bad_index_value(self):
 
346
        error = errors.BadIndexValue("foo")
 
347
        self.assertEqual("The value 'foo' is not a valid value.",
 
348
            str(error))
 
349
 
150
350
    def test_bzrnewerror_is_deprecated(self):
151
351
        class DeprecatedError(errors.BzrNewError):
152
352
            pass
186
386
            str(error))
187
387
 
188
388
    def test_transport_not_possible(self):
189
 
        e = errors.TransportNotPossible('readonly', 'original error')
190
 
        self.assertEqual('Transport operation not possible:'
191
 
                         ' readonly original error', str(e))
 
389
        error = errors.TransportNotPossible('readonly', 'original error')
 
390
        self.assertEqualDiff('Transport operation not possible:'
 
391
                         ' readonly original error', str(error))
192
392
 
193
393
    def assertSocketConnectionError(self, expected, *args, **kwargs):
194
394
        """Check the formatting of a SocketConnectionError exception"""
233
433
            host='ahost', port=444, msg='Unable to connect to ssh host',
234
434
            orig_error='my_error')
235
435
 
 
436
    def test_target_not_branch(self):
 
437
        """Test the formatting of TargetNotBranch."""
 
438
        error = errors.TargetNotBranch('foo')
 
439
        self.assertEqual(
 
440
            "Your branch does not have all of the revisions required in "
 
441
            "order to merge this merge directive and the target "
 
442
            "location specified in the merge directive is not a branch: "
 
443
            "foo.", str(error))
 
444
 
 
445
    def test_malformed_bug_identifier(self):
 
446
        """Test the formatting of MalformedBugIdentifier."""
 
447
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
 
448
        self.assertEqual(
 
449
            'Did not understand bug identifier bogus: reason for bogosity. '
 
450
            'See "bzr help bugs" for more information on this feature.',
 
451
            str(error))
 
452
 
 
453
    def test_unknown_bug_tracker_abbreviation(self):
 
454
        """Test the formatting of UnknownBugTrackerAbbreviation."""
 
455
        branch = self.make_branch('some_branch')
 
456
        error = errors.UnknownBugTrackerAbbreviation('xxx', branch)
 
457
        self.assertEqual(
 
458
            "Cannot find registered bug tracker called xxx on %s" % branch,
 
459
            str(error))
 
460
 
 
461
    def test_unexpected_smart_server_response(self):
 
462
        e = errors.UnexpectedSmartServerResponse(('not yes',))
 
463
        self.assertEqual(
 
464
            "Could not understand response from smart server: ('not yes',)",
 
465
            str(e))
 
466
 
 
467
    def test_unknown_container_format(self):
 
468
        """Test the formatting of UnknownContainerFormatError."""
 
469
        e = errors.UnknownContainerFormatError('bad format string')
 
470
        self.assertEqual(
 
471
            "Unrecognised container format: 'bad format string'",
 
472
            str(e))
 
473
 
 
474
    def test_unexpected_end_of_container(self):
 
475
        """Test the formatting of UnexpectedEndOfContainerError."""
 
476
        e = errors.UnexpectedEndOfContainerError()
 
477
        self.assertEqual(
 
478
            "Unexpected end of container stream", str(e))
 
479
 
 
480
    def test_unknown_record_type(self):
 
481
        """Test the formatting of UnknownRecordTypeError."""
 
482
        e = errors.UnknownRecordTypeError("X")
 
483
        self.assertEqual(
 
484
            "Unknown record type: 'X'",
 
485
            str(e))
 
486
 
 
487
    def test_invalid_record(self):
 
488
        """Test the formatting of InvalidRecordError."""
 
489
        e = errors.InvalidRecordError("xxx")
 
490
        self.assertEqual(
 
491
            "Invalid record: xxx",
 
492
            str(e))
 
493
 
 
494
    def test_container_has_excess_data(self):
 
495
        """Test the formatting of ContainerHasExcessDataError."""
 
496
        e = errors.ContainerHasExcessDataError("excess bytes")
 
497
        self.assertEqual(
 
498
            "Container has data after end marker: 'excess bytes'",
 
499
            str(e))
 
500
 
 
501
    def test_duplicate_record_name_error(self):
 
502
        """Test the formatting of DuplicateRecordNameError."""
 
503
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
 
504
        self.assertEqual(
 
505
            "Container has multiple records with the same name: n\xc3\xa5me",
 
506
            str(e))
 
507
 
 
508
    def test_check_error(self):
 
509
        # This has a member called 'message', which is problematic in
 
510
        # python2.5 because that is a slot on the base Exception class
 
511
        e = errors.BzrCheckError('example check failure')
 
512
        self.assertEqual(
 
513
            "Internal check failed: example check failure",
 
514
            str(e))
 
515
        self.assertTrue(e.internal_error)
 
516
 
 
517
    def test_repository_data_stream_error(self):
 
518
        """Test the formatting of RepositoryDataStreamError."""
 
519
        e = errors.RepositoryDataStreamError(u"my reason")
 
520
        self.assertEqual(
 
521
            "Corrupt or incompatible data stream: my reason", str(e))
 
522
 
 
523
    def test_immortal_pending_deletion_message(self):
 
524
        err = errors.ImmortalPendingDeletion('foo')
 
525
        self.assertEquals(
 
526
            "Unable to delete transform temporary directory foo.  "
 
527
            "Please examine foo to see if it contains any files "
 
528
            "you wish to keep, and delete it when you are done.",
 
529
            str(err))
 
530
 
 
531
    def test_unable_create_symlink(self):
 
532
        err = errors.UnableCreateSymlink()
 
533
        self.assertEquals(
 
534
            "Unable to create symlink on this platform",
 
535
            str(err))
 
536
        err = errors.UnableCreateSymlink(path=u'foo')
 
537
        self.assertEquals(
 
538
            "Unable to create symlink 'foo' on this platform",
 
539
            str(err))
 
540
        err = errors.UnableCreateSymlink(path=u'\xb5')
 
541
        self.assertEquals(
 
542
            "Unable to create symlink u'\\xb5' on this platform",
 
543
            str(err))
 
544
 
 
545
    def test_invalid_url_join(self):
 
546
        """Test the formatting of InvalidURLJoin."""
 
547
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
 
548
        self.assertEqual(
 
549
            "Invalid URL join request: Reason: 'base path' + ('args',)",
 
550
            str(e))
 
551
 
 
552
    def test_incorrect_url(self):
 
553
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
 
554
        self.assertEquals(
 
555
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
 
556
             "http://bug.com/"),
 
557
            str(err))
 
558
 
 
559
    def test_unable_encode_path(self):
 
560
        err = errors.UnableEncodePath('foo', 'executable')
 
561
        self.assertEquals("Unable to encode executable path 'foo' in "
 
562
            "user encoding " + osutils.get_user_encoding(),
 
563
            str(err))
 
564
 
 
565
    def test_unknown_format(self):
 
566
        err = errors.UnknownFormatError('bar', kind='foo')
 
567
        self.assertEquals("Unknown foo format: 'bar'", str(err))
 
568
 
 
569
    def test_unknown_rules(self):
 
570
        err = errors.UnknownRules(['foo', 'bar'])
 
571
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
 
572
 
 
573
    def test_hook_failed(self):
 
574
        # Create an exc_info tuple by raising and catching an exception.
 
575
        try:
 
576
            1/0
 
577
        except ZeroDivisionError:
 
578
            exc_info = sys.exc_info()
 
579
        err = errors.HookFailed('hook stage', 'hook name', exc_info, warn=False)
 
580
        self.assertStartsWith(
 
581
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
 
582
        self.assertEndsWith(
 
583
            str(err), 'integer division or modulo by zero')
 
584
 
 
585
    def test_tip_change_rejected(self):
 
586
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
 
587
        self.assertEquals(
 
588
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
 
589
            unicode(err))
 
590
        self.assertEquals(
 
591
            'Tip change rejected: Unicode message\xe2\x80\xbd',
 
592
            str(err))
 
593
 
 
594
    def test_error_from_smart_server(self):
 
595
        error_tuple = ('error', 'tuple')
 
596
        err = errors.ErrorFromSmartServer(error_tuple)
 
597
        self.assertEquals(
 
598
            "Error received from smart server: ('error', 'tuple')", str(err))
 
599
 
 
600
    def test_untranslateable_error_from_smart_server(self):
 
601
        error_tuple = ('error', 'tuple')
 
602
        orig_err = errors.ErrorFromSmartServer(error_tuple)
 
603
        err = errors.UnknownErrorFromSmartServer(orig_err)
 
604
        self.assertEquals(
 
605
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
 
606
 
 
607
    def test_smart_message_handler_error(self):
 
608
        # Make an exc_info tuple.
 
609
        try:
 
610
            raise Exception("example error")
 
611
        except Exception:
 
612
            exc_info = sys.exc_info()
 
613
        err = errors.SmartMessageHandlerError(exc_info)
 
614
        self.assertStartsWith(
 
615
            str(err), "The message handler raised an exception:\n")
 
616
        self.assertEndsWith(str(err), "Exception: example error\n")
 
617
 
 
618
    def test_must_have_working_tree(self):
 
619
        err = errors.MustHaveWorkingTree('foo', 'bar')
 
620
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
 
621
                                   " working tree.")
 
622
 
 
623
    def test_no_such_view(self):
 
624
        err = errors.NoSuchView('foo')
 
625
        self.assertEquals("No such view: foo.", str(err))
 
626
 
 
627
    def test_views_not_supported(self):
 
628
        err = errors.ViewsNotSupported('atree')
 
629
        err_str = str(err)
 
630
        self.assertStartsWith(err_str, "Views are not supported by ")
 
631
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
 
632
            "tree to a later format.")
 
633
 
 
634
    def test_file_outside_view(self):
 
635
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
 
636
        self.assertEquals('Specified file "baz" is outside the current view: '
 
637
            'foo, bar', str(err))
 
638
 
 
639
    def test_invalid_shelf_id(self):
 
640
        invalid_id = "foo"
 
641
        err = errors.InvalidShelfId(invalid_id)
 
642
        self.assertEqual('"foo" is not a valid shelf id, '
 
643
            'try a number instead.', str(err))
 
644
 
 
645
    def test_unresumable_write_group(self):
 
646
        repo = "dummy repo"
 
647
        wg_tokens = ['token']
 
648
        reason = "a reason"
 
649
        err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
 
650
        self.assertEqual(
 
651
            "Repository dummy repo cannot resume write group "
 
652
            "['token']: a reason", str(err))
 
653
 
 
654
    def test_unsuspendable_write_group(self):
 
655
        repo = "dummy repo"
 
656
        err = errors.UnsuspendableWriteGroup(repo)
 
657
        self.assertEqual(
 
658
            'Repository dummy repo cannot suspend a write group.', str(err))
 
659
 
 
660
    def test_not_branch_no_args(self):
 
661
        err = errors.NotBranchError('path')
 
662
        self.assertEqual('Not a branch: "path".', str(err))
 
663
 
 
664
    def test_not_branch_bzrdir_with_repo(self):
 
665
        bzrdir = self.make_repository('repo').bzrdir
 
666
        err = errors.NotBranchError('path', bzrdir=bzrdir)
 
667
        self.assertEqual(
 
668
            'Not a branch: "path": location is a repository.', str(err))
 
669
 
 
670
    def test_not_branch_bzrdir_without_repo(self):
 
671
        bzrdir = self.make_bzrdir('bzrdir')
 
672
        err = errors.NotBranchError('path', bzrdir=bzrdir)
 
673
        self.assertEqual('Not a branch: "path".', str(err))
 
674
 
 
675
    def test_not_branch_laziness(self):
 
676
        real_bzrdir = self.make_bzrdir('path')
 
677
        class FakeBzrDir(object):
 
678
            def __init__(self):
 
679
                self.calls = []
 
680
            def open_repository(self):
 
681
                self.calls.append('open_repository')
 
682
                raise errors.NoRepositoryPresent(real_bzrdir)
 
683
        fake_bzrdir = FakeBzrDir()
 
684
        err = errors.NotBranchError('path', bzrdir=fake_bzrdir)
 
685
        self.assertEqual([], fake_bzrdir.calls)
 
686
        str(err)
 
687
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
688
        # Stringifying twice doesn't try to open a repository twice.
 
689
        str(err)
 
690
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
691
 
 
692
    def test_invalid_pattern(self):
 
693
        error = errors.InvalidPattern('Bad pattern msg.')
 
694
        self.assertEqualDiff("Invalid pattern(s) found. Bad pattern msg.",
 
695
            str(error))
 
696
 
 
697
    def test_recursive_bind(self):
 
698
        error = errors.RecursiveBind('foo_bar_branch')
 
699
        msg = ('Branch "foo_bar_branch" appears to be bound to itself. '
 
700
            'Please use `bzr unbind` to fix.')
 
701
        self.assertEqualDiff(msg, str(error))
236
702
 
237
703
 
238
704
class PassThroughError(errors.BzrError):
239
 
    
 
705
 
240
706
    _fmt = """Pass through %(foo)s and %(bar)s"""
241
707
 
242
708
    def __init__(self, foo, bar):
249
715
 
250
716
 
251
717
class ErrorWithNoFormat(errors.BzrError):
252
 
    """This class has a docstring but no format string."""
 
718
    __doc__ = """This class has a docstring but no format string."""
253
719
 
254
720
 
255
721
class TestErrorFormatting(TestCase):
256
 
    
 
722
 
257
723
    def test_always_str(self):
258
724
        e = PassThroughError(u'\xb5', 'bar')
259
725
        self.assertIsInstance(e.__str__(), str)
270
736
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
271
737
                lambda x: str(x), e)
272
738
        ## s = str(e)
273
 
        self.assertEqual(s, 
 
739
        self.assertEqual(s,
274
740
                "This class has a docstring but no format string.")
275
741
 
276
742
    def test_mismatched_format_args(self):
281
747
        self.assertStartsWith(
282
748
            str(e), 'Unprintable exception ErrorWithBadFormat')
283
749
 
 
750
    def test_cannot_bind_address(self):
 
751
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
 
752
        e = errors.CannotBindAddress('example.com', 22,
 
753
            socket.error(13, 'Permission denied'))
 
754
        self.assertContainsRe(str(e),
 
755
            r'Cannot bind address "example\.com:22":.*Permission denied')
 
756
 
 
757
    def test_file_timestamp_unavailable(self):            
 
758
        e = errors.FileTimestampUnavailable("/path/foo")
 
759
        self.assertEquals("The filestamp for /path/foo is not available.",
 
760
            str(e))
 
761
            
 
762
    def test_transform_rename_failed(self):
 
763
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
 
764
        self.assertEquals(
 
765
            u"Failed to rename from to to: readonly file",
 
766
            str(e))