← 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: John Arbash Meinel
  • Date: 2013-05-19 14:29:37 UTC
  • mfrom: (6437.63.9 2.5)
  • mto: (6437.63.10 2.5)
  • mto: This revision was merged to the branch mainline in revision 6575.
  • Revision ID: john@arbash-meinel.com-20130519142937-21ykz2n2y2f22za9
Merge in the actual 2.5 branch. It seems I failed before

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-2011 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,
23
 
    )
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.
 
27
    osutils,
 
28
    urlutils,
 
29
    )
 
30
from bzrlib.tests import (
 
31
    TestCase,
 
32
    TestCaseWithTransport,
 
33
    TestSkipped,
 
34
    )
29
35
 
30
36
 
31
37
class TestErrors(TestCaseWithTransport):
32
38
 
 
39
    def test_no_arg_named_message(self):
 
40
        """Ensure the __init__ and _fmt in errors do not have "message" arg.
 
41
 
 
42
        This test fails if __init__ or _fmt in errors has an argument
 
43
        named "message" as this can cause errors in some Python versions.
 
44
        Python 2.5 uses a slot for StandardError.message.
 
45
        See bug #603461
 
46
        """
 
47
        fmt_pattern = re.compile("%\(message\)[sir]")
 
48
        subclasses_present = getattr(errors.BzrError, '__subclasses__', None)
 
49
        if not subclasses_present:
 
50
            raise TestSkipped('__subclasses__ attribute required for classes. '
 
51
                'Requires Python 2.5 or later.')
 
52
        for c in errors.BzrError.__subclasses__():
 
53
            init = getattr(c, '__init__', None)
 
54
            fmt = getattr(c, '_fmt', None)
 
55
            if init:
 
56
                args = inspect.getargspec(init)[0]
 
57
                self.assertFalse('message' in args,
 
58
                    ('Argument name "message" not allowed for '
 
59
                    '"errors.%s.__init__"' % c.__name__))
 
60
            if fmt and fmt_pattern.search(fmt):
 
61
                self.assertFalse(True, ('"message" not allowed in '
 
62
                    '"errors.%s._fmt"' % c.__name__))
 
63
 
 
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
 
33
85
    def test_disabled_method(self):
34
86
        error = errors.DisabledMethod("class name")
35
87
        self.assertEqualDiff(
40
92
        self.assertEqualDiff('File id {a_file_id} already exists in inventory'
41
93
                             ' as foo', str(error))
42
94
 
 
95
    def test_duplicate_help_prefix(self):
 
96
        error = errors.DuplicateHelpPrefix('foo')
 
97
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
 
98
            str(error))
 
99
 
 
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
    def test_incompatibleAPI(self):
 
107
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
 
108
        self.assertEqualDiff(
 
109
            'The API for "module" is not compatible with "(1, 2, 3)". '
 
110
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
 
111
            str(error))
 
112
 
 
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
    def test_in_process_transport(self):
 
127
        error = errors.InProcessTransport('fpp')
 
128
        self.assertEqualDiff(
 
129
            "The transport 'fpp' is only accessible within this process.",
 
130
            str(error))
 
131
 
 
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
 
43
146
    def test_inventory_modified(self):
44
147
        error = errors.InventoryModified("a tree to be repred")
45
148
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
47
150
            "read without data loss.",
48
151
            str(error))
49
152
 
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))
 
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))
58
158
 
59
159
    def test_lock_active(self):
60
160
        error = errors.LockActive("lock description")
62
162
            "cannot be broken.",
63
163
            str(error))
64
164
 
 
165
    def test_lock_corrupt(self):
 
166
        error = errors.LockCorrupt("corruption info")
 
167
        self.assertEqualDiff("Lock is apparently held, but corrupted: "
 
168
            "corruption info\n"
 
169
            "Use 'bzr break-lock' to clear it",
 
170
            str(error))
 
171
 
 
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
 
65
185
    def test_knit_header_error(self):
66
186
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
67
187
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
68
 
                         " for file path/to/file", str(error))
 
188
                         " for file \"path/to/file\".", str(error))
69
189
 
70
190
    def test_knit_index_unknown_method(self):
71
191
        error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
78
198
        error = errors.MediumNotConnected("a medium")
79
199
        self.assertEqualDiff(
80
200
            "The medium 'a medium' is not connected.", str(error))
81
 
        
 
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
 
82
209
    def test_no_repo(self):
83
210
        dir = bzrdir.BzrDir.create(self.get_url())
84
211
        error = errors.NoRepositoryPresent(dir)
85
212
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
86
213
        self.assertEqual(-1, str(error).find((dir.transport.base)))
87
 
        
 
214
 
88
215
    def test_no_smart_medium(self):
89
216
        error = errors.NoSmartMedium("a transport")
90
217
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
91
218
            "smart protocol.",
92
219
            str(error))
93
220
 
 
221
    def test_no_help_topic(self):
 
222
        error = errors.NoHelpTopic("topic")
 
223
        self.assertEqualDiff("No help could be found for 'topic'. "
 
224
            "Please use 'bzr help topics' to obtain a list of topics.",
 
225
            str(error))
 
226
 
94
227
    def test_no_such_id(self):
95
228
        error = errors.NoSuchId("atree", "anid")
96
 
        self.assertEqualDiff("The file id anid is not present in the tree "
 
229
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
97
230
            "atree.",
98
231
            str(error))
99
232
 
100
233
    def test_no_such_revision_in_tree(self):
101
234
        error = errors.NoSuchRevisionInTree("atree", "anid")
102
 
        self.assertEqualDiff("The revision id anid is not present in the tree "
103
 
            "atree.",
104
 
            str(error))
 
235
        self.assertEqualDiff("The revision id {anid} is not present in the"
 
236
                             " tree atree.", str(error))
105
237
        self.assertIsInstance(error, errors.NoSuchRevision)
106
238
 
 
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
 
107
244
    def test_not_write_locked(self):
108
245
        error = errors.NotWriteLocked('a thing to repr')
109
246
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
110
247
            "to be.",
111
248
            str(error))
112
249
 
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))
 
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)
117
255
 
118
256
    def test_too_many_concurrent_requests(self):
119
257
        error = errors.TooManyConcurrentRequests("a medium")
120
258
        self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
121
259
            "request limit. Be sure to finish_writing and finish_reading on "
122
 
            "the current request that is open.",
 
260
            "the currently open request.",
 
261
            str(error))
 
262
 
 
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'.",
123
267
            str(error))
124
268
 
125
269
    def test_unknown_hook(self):
132
276
            " of bzrlib.",
133
277
            str(error))
134
278
 
 
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
 
135
302
    def test_up_to_date(self):
136
 
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
137
 
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
138
 
                             "format 0.0.4 is already at the most "
139
 
                             "recent format.",
140
 
                             str(error))
 
303
        error = errors.UpToDateFormat("someformat")
 
304
        self.assertEqualDiff(
 
305
            "The branch format someformat is already at the most "
 
306
            "recent format.", str(error))
141
307
 
142
308
    def test_corrupt_repository(self):
143
309
        repo = self.make_repository('.')
147
313
                             repo.bzrdir.root_transport.base,
148
314
                             str(error))
149
315
 
150
 
    def test_bzrnewerror_is_deprecated(self):
151
 
        class DeprecatedError(errors.BzrNewError):
152
 
            pass
153
 
        self.callDeprecated(['BzrNewError was deprecated in bzr 0.13; '
154
 
             'please convert DeprecatedError to use BzrError instead'],
155
 
            DeprecatedError)
 
316
    def test_read_error(self):
 
317
        # a unicode path to check that %r is being used.
 
318
        path = u'a path'
 
319
        error = errors.ReadError(path)
 
320
        self.assertEqualDiff("Error reading from u'a path'.", str(error))
 
321
 
 
322
    def test_bad_index_format_signature(self):
 
323
        error = errors.BadIndexFormatSignature("foo", "bar")
 
324
        self.assertEqual("foo is not an index of type bar.",
 
325
            str(error))
 
326
 
 
327
    def test_bad_index_data(self):
 
328
        error = errors.BadIndexData("foo")
 
329
        self.assertEqual("Error in data for index foo.",
 
330
            str(error))
 
331
 
 
332
    def test_bad_index_duplicate_key(self):
 
333
        error = errors.BadIndexDuplicateKey("foo", "bar")
 
334
        self.assertEqual("The key 'foo' is already in index 'bar'.",
 
335
            str(error))
 
336
 
 
337
    def test_bad_index_key(self):
 
338
        error = errors.BadIndexKey("foo")
 
339
        self.assertEqual("The key 'foo' is not a valid key.",
 
340
            str(error))
 
341
 
 
342
    def test_bad_index_options(self):
 
343
        error = errors.BadIndexOptions("foo")
 
344
        self.assertEqual("Could not parse options for index foo.",
 
345
            str(error))
 
346
 
 
347
    def test_bad_index_value(self):
 
348
        error = errors.BadIndexValue("foo")
 
349
        self.assertEqual("The value 'foo' is not a valid value.",
 
350
            str(error))
156
351
 
157
352
    def test_bzrerror_from_literal_string(self):
158
353
        # Some code constructs BzrError from a literal string, in which case
186
381
            str(error))
187
382
 
188
383
    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))
 
384
        error = errors.TransportNotPossible('readonly', 'original error')
 
385
        self.assertEqualDiff('Transport operation not possible:'
 
386
                         ' readonly original error', str(error))
192
387
 
193
388
    def assertSocketConnectionError(self, expected, *args, **kwargs):
194
389
        """Check the formatting of a SocketConnectionError exception"""
233
428
            host='ahost', port=444, msg='Unable to connect to ssh host',
234
429
            orig_error='my_error')
235
430
 
 
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
    def test_malformed_bug_identifier(self):
 
441
        """Test the formatting of MalformedBugIdentifier."""
 
442
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
 
443
        self.assertEqual(
 
444
            'Did not understand bug identifier bogus: reason for bogosity. '
 
445
            'See "bzr help bugs" for more information on this feature.',
 
446
            str(error))
 
447
 
 
448
    def test_unknown_bug_tracker_abbreviation(self):
 
449
        """Test the formatting of UnknownBugTrackerAbbreviation."""
 
450
        branch = self.make_branch('some_branch')
 
451
        error = errors.UnknownBugTrackerAbbreviation('xxx', branch)
 
452
        self.assertEqual(
 
453
            "Cannot find registered bug tracker called xxx on %s" % branch,
 
454
            str(error))
 
455
 
 
456
    def test_unexpected_smart_server_response(self):
 
457
        e = errors.UnexpectedSmartServerResponse(('not yes',))
 
458
        self.assertEqual(
 
459
            "Could not understand response from smart server: ('not yes',)",
 
460
            str(e))
 
461
 
 
462
    def test_unknown_container_format(self):
 
463
        """Test the formatting of UnknownContainerFormatError."""
 
464
        e = errors.UnknownContainerFormatError('bad format string')
 
465
        self.assertEqual(
 
466
            "Unrecognised container format: 'bad format string'",
 
467
            str(e))
 
468
 
 
469
    def test_unexpected_end_of_container(self):
 
470
        """Test the formatting of UnexpectedEndOfContainerError."""
 
471
        e = errors.UnexpectedEndOfContainerError()
 
472
        self.assertEqual(
 
473
            "Unexpected end of container stream", str(e))
 
474
 
 
475
    def test_unknown_record_type(self):
 
476
        """Test the formatting of UnknownRecordTypeError."""
 
477
        e = errors.UnknownRecordTypeError("X")
 
478
        self.assertEqual(
 
479
            "Unknown record type: 'X'",
 
480
            str(e))
 
481
 
 
482
    def test_invalid_record(self):
 
483
        """Test the formatting of InvalidRecordError."""
 
484
        e = errors.InvalidRecordError("xxx")
 
485
        self.assertEqual(
 
486
            "Invalid record: xxx",
 
487
            str(e))
 
488
 
 
489
    def test_container_has_excess_data(self):
 
490
        """Test the formatting of ContainerHasExcessDataError."""
 
491
        e = errors.ContainerHasExcessDataError("excess bytes")
 
492
        self.assertEqual(
 
493
            "Container has data after end marker: 'excess bytes'",
 
494
            str(e))
 
495
 
 
496
    def test_duplicate_record_name_error(self):
 
497
        """Test the formatting of DuplicateRecordNameError."""
 
498
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
 
499
        self.assertEqual(
 
500
            "Container has multiple records with the same name: n\xc3\xa5me",
 
501
            str(e))
 
502
 
 
503
    def test_check_error(self):
 
504
        # This has a member called 'message', which is problematic in
 
505
        # python2.5 because that is a slot on the base Exception class
 
506
        e = errors.BzrCheckError('example check failure')
 
507
        self.assertEqual(
 
508
            "Internal check failed: example check failure",
 
509
            str(e))
 
510
        self.assertTrue(e.internal_error)
 
511
 
 
512
    def test_repository_data_stream_error(self):
 
513
        """Test the formatting of RepositoryDataStreamError."""
 
514
        e = errors.RepositoryDataStreamError(u"my reason")
 
515
        self.assertEqual(
 
516
            "Corrupt or incompatible data stream: my reason", str(e))
 
517
 
 
518
    def test_immortal_pending_deletion_message(self):
 
519
        err = errors.ImmortalPendingDeletion('foo')
 
520
        self.assertEquals(
 
521
            "Unable to delete transform temporary directory foo.  "
 
522
            "Please examine foo to see if it contains any files "
 
523
            "you wish to keep, and delete it when you are done.",
 
524
            str(err))
 
525
 
 
526
    def test_unable_create_symlink(self):
 
527
        err = errors.UnableCreateSymlink()
 
528
        self.assertEquals(
 
529
            "Unable to create symlink on this platform",
 
530
            str(err))
 
531
        err = errors.UnableCreateSymlink(path=u'foo')
 
532
        self.assertEquals(
 
533
            "Unable to create symlink 'foo' on this platform",
 
534
            str(err))
 
535
        err = errors.UnableCreateSymlink(path=u'\xb5')
 
536
        self.assertEquals(
 
537
            "Unable to create symlink u'\\xb5' on this platform",
 
538
            str(err))
 
539
 
 
540
    def test_invalid_url_join(self):
 
541
        """Test the formatting of InvalidURLJoin."""
 
542
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
 
543
        self.assertEqual(
 
544
            "Invalid URL join request: Reason: 'base path' + ('args',)",
 
545
            str(e))
 
546
 
 
547
    def test_incorrect_url(self):
 
548
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
 
549
        self.assertEquals(
 
550
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
 
551
             "http://bug.com/"),
 
552
            str(err))
 
553
 
 
554
    def test_unable_encode_path(self):
 
555
        err = errors.UnableEncodePath('foo', 'executable')
 
556
        self.assertEquals("Unable to encode executable path 'foo' in "
 
557
            "user encoding " + osutils.get_user_encoding(),
 
558
            str(err))
 
559
 
 
560
    def test_unknown_format(self):
 
561
        err = errors.UnknownFormatError('bar', kind='foo')
 
562
        self.assertEquals("Unknown foo format: 'bar'", str(err))
 
563
 
 
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))
236
705
 
237
706
 
238
707
class PassThroughError(errors.BzrError):
239
 
    
 
708
 
240
709
    _fmt = """Pass through %(foo)s and %(bar)s"""
241
710
 
242
711
    def __init__(self, foo, bar):
249
718
 
250
719
 
251
720
class ErrorWithNoFormat(errors.BzrError):
252
 
    """This class has a docstring but no format string."""
 
721
    __doc__ = """This class has a docstring but no format string."""
253
722
 
254
723
 
255
724
class TestErrorFormatting(TestCase):
256
 
    
 
725
 
257
726
    def test_always_str(self):
258
727
        e = PassThroughError(u'\xb5', 'bar')
259
728
        self.assertIsInstance(e.__str__(), str)
266
735
 
267
736
    def test_missing_format_string(self):
268
737
        e = ErrorWithNoFormat(param='randomvalue')
269
 
        s = self.callDeprecated(
270
 
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
271
 
                lambda x: str(x), e)
272
 
        ## s = str(e)
273
 
        self.assertEqual(s, 
274
 
                "This class has a docstring but no format string.")
 
738
        self.assertStartsWith(str(e),
 
739
            "Unprintable exception ErrorWithNoFormat")
275
740
 
276
741
    def test_mismatched_format_args(self):
277
742
        # Even though ErrorWithBadFormat's format string does not match the
281
746
        self.assertStartsWith(
282
747
            str(e), 'Unprintable exception ErrorWithBadFormat')
283
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))